
<p class="has-drop-cap wp-block-paragraph">1 När Stig H Johansson styrde egentränade <strong>The Onion </strong>(e. Quick Pay) till seger i Sprintermästaren 1983 stannade klockan på 1.12,0a/1.609 meter – nytt världsrekord alla kategorier på tusenmetersbana. Sedan dess har det legat rekordglans över sprinterfesten i Halmstad, där den allra snabbaste vinnaren heter <strong>Uncle Lasse</strong> (e. Donato Hanover).</p>



<p class="wp-block-paragraph">När Stefan Melanders Uncle Lasse med Örjan Kihlström i sulkyn utrustades med helstängt huvudlag i finalen för sju år sedan gick det fort. Riktigt fort! Efter 1.08,0 första kilometern kom Uncle Lasse hem på 1.09,3 vid överlägsen seger och noteringen var nytt Europarekord!</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/11/francescozet45-617x333.jpg" alt="" class="wp-image-379758"/><figcaption class="wp-element-caption">Francesco Zet och Daniel Redén. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Fjolårsvinnaren <strong>Francesco Zet </strong>(e. Father Patrick) var tiondelen långsammare vid sin seger, men 1.09,4 är svenskt rekord för fyraåriga hingstar och valacker.</p>



<p class="wp-block-paragraph">Ikväll är 23 fyraåringar anmälda till årets upplaga av Sprintermästaren och de två mest meriterade hästarna kommer från Daniel Redéns stall. Solvallatränaren står bakom tre av de fem senaste vinnarna i loppet, förutom Francesco Zet även <strong>Perfect Spirit </strong>(e. Andover Hall) och <strong>Don Fanucci Zet</strong> (e. Hard Livin).</p>



<p class="wp-block-paragraph">Ston testas allt mer sällan i ”stora” Sprintermästaren, men i årets startfält finns <strong>Dea Grif (</strong>e. Varenne) med mot hingstarna och valackerna. Hon har historien emot sig – senaste sto att vinna öppna klassen var Christer Nylanders <strong>Serena</strong> (e. Nuclear Kosmos) 1994 . Förutom Serena har <strong>Lime Rodney</strong> (Captain Rodney), <strong>Charm Asserdal</strong> (e. Train Bloc) och  <strong>Drottning Sund </strong>(e. Tibur) lyckats med konststycket  1972, 1977 respektive 1990.</p>



<h2 class="wp-block-heading">Alla Sprintermästare på 1.10,0 eller snabbare:</h2>



<p class="wp-block-paragraph"><strong>År, vinnare (far) – Kusk (tränare) – Segertid</strong></p>



<ul class="wp-block-list">
<li>2016 <strong>Uncle Lasse </strong>(e. Donato Hanover) – Örjan Kihlström (Stefan Melander) – 1.09,3</li>



<li>2022 <strong>Francesco Zet</strong> (e. Father Patrick) – Örjan Kihlström (Daniel Redén) – 1.09,4</li>



<li>2020 <strong>Don Fanucci Zet</strong> (e. Hard Living) – Örjan Kihlström (Daniel Redén) – 1.09,6</li>



<li>2009 <strong>Lavec Kronos </strong>(e. Enjoy Lavec) – Lutfi Kolgjini – 1.09,7</li>



<li>2012 <strong>Brad de Veluwe </strong>(e. Andover Hall) – Tuomas Korvenoja – 1.09,7</li>



<li>2021 <strong>Önas Prince </strong>(e. Chocolatier) – Per Nordström – 1.09,8</li>



<li>2015 <strong>Nuncio </strong>(e. Andover Hall) – Stefan Melander – 1.10,0</li>



<li>2017 <strong>Diamanten</strong> (e. Adrian Chip) – Christoffer Eriksson (Robert Bergh) – 1.10,0</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">2 Medan sex vinnare av Sprintermästaren travat under 1.10 vid finalseger, så väntar Stosprintern fortfarande på sin första 1.09-travare. Löpningsrekordet innehas av Robert Bergh-tränade <strong>Fifty Cent Piece</strong> (e. Muscle Hill), som följde upp fina unghästmerieter i Nordamerika med en urstark fyraåringssäsong i Sverige, som även innehöll segrar i Drottning Silvias Pokal och Breeders Crown.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/07/fiftycentpiece-617x333.jpg" alt="" class="wp-image-186511"/><figcaption class="wp-element-caption">Fifty Cent Piece och Robert Bergh vann Stosprintern på löpningsrekordet 1.10,5a/1.609 meter. Foto Lars B Persson</figcaption></figure>



<p class="wp-block-paragraph">I Stosprintern travade hon 1.10,4a/1.609 meter vid vinsten före Betting Pacer (e. Maharajah) i finalen.</p>



<p class="wp-block-paragraph">Vid ytterligare två tillfällen har vinnaren i stoklassen travat under 1.11. 2017 vann Roger Walmann-tränade <strong>Caddie Lisieux </strong>(e. Ready Cash) – precis som Fifty Cent Piece ägd av Srf Stable – på 1.10,6 tillsammans med Kenneth Haugstad och ifjol var det firma Paul Hagoort/Robin Bakker i topp genom <strong>Chebba Mil</strong> (e. Readly Express) på 1.10,7a.</p>



<p class="wp-block-paragraph">Svenska rekordet för svenskfödda hästar har Timo Nurmos-tränade <strong>Miss Imperatrice</strong> (e. Mister J.P.) på 1.09,9a/1.609 meter från Solvalla i höstas. Snabbaste utländska sto är Tomas Malmqvists fransyska <strong>Jazzy Perinne</strong> (e. Django Riff), som ju vann Fyraåringseliten i maj på 1.09,0.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/06/06v75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Halmstads tävlingar ikväll.</a></p>



<p class="wp-block-paragraph">Sprintermästarkvällen har V75-spel och du vet väl att du kan spela tillsammans med Sulkysports expert. Här finns andelar till Sulkysports system:</p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2023-07-06_18_6" target="_blank" rel="noreferrer noopener">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">3 Alla blickar mot <strong>Halmstad</strong> (första start 17.00) denna Sprintermästartorsdag? Visst är det så, men det tävlas på ytterligare två svenska banor idag.</p>



<p class="wp-block-paragraph">Ikväll fyller även <strong>Visby</strong> (start 17.45) på med nio lopp och en intressant debutant dyker upp i nolloppet. Det handlar om treårige <strong>Xanthis Illusion</strong> (e. Express Bourbon), som är lillebror till fjolårets Kriterievinnare <strong>Xanthis Harvey </strong>(e. Propulsion), som själv dyker upp i Sprintermästaren ikväll. Markus B Svedberg tränar och kör debutanten, som ropades in för 375.000 kronor på Elitauktionen för två år sedan.</p>



<p class="wp-block-paragraph">Kalmartränaren Thomas Jonssons femåring <strong>Bugatti Veyron </strong>(e. Ens Snapshot) vann sex lopp förra året – samtliga på Visbytravet där han blev segerrikaste häst under säsongen. I år har han gjort fem starter på ön, men väntar på första triumfen. Är det dags ikväll efter fyra andraplatser?</p>



<p class="wp-block-paragraph">Först ut är <strong>Årjäng </strong>(start 12.20) och Färjestadtränaren Jonas Moberg gästar med fyraårige <strong>Exclusive Creation</strong> (e. Raja Mirchi), som efter att ha debuterat i april tagit kliv efter kliv på utvecklingskurvan och nu ståtar med två raka segrar. Den senaste kom i första starten på barfotabalans, där valacken rekordsänkte rejält. </p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/06/230706.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till torsdagens tävlingar.</a></p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">4 Det är mycket blågult i dagens evakueringslopp Prix de Pont-l’Eveque Et de la Confrerie (€26.000) i <strong>Lisieux</strong> (första start 13.30). Fem svenskfödda hästar kommer till start, varav två alltjämt är svensktränade.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/11/jorgenseriksson-617x333.jpg" alt="" class="wp-image-122834"/><figcaption class="wp-element-caption">Jörgen S Eriksson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Jörgen S Eriksson är själv på plats för att köra <strong>Dollar Doc</strong> (e. Ready Cash), medan Markus B Svedberg lånar ut <strong>Certainly</strong> (e. Readly Express) till Frank Ouvrie.</p>



<p class="wp-block-paragraph">David Cinier prövar i sin tur lyckan med <strong>Silver Bullit </strong>(e. Orlando Vici) som vann debuten på fransk mark och har även Ready Cash-sonen <strong>Deep Pockets </strong>till start. Pierre Levesque startar i sin tur <strong>Happy Few</strong> (e. Ready Cash) i detta lopp över 2.675 meter autostart och med 11.700 euro som belöning till vinnaren.</p>



<p class="wp-block-paragraph">Det tävlas även i <strong>Vichy</strong> (första start 18.17) under kvällen och där startar Björn Goop Ready Cash-hingsten <strong>Kamikaze du Campus </strong>i Prix Jean Boillereau (€29.000). David Bekaert sitter upp bakom treåringen som inlett året med tre segrar på fem försök.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">5 Sko- samt sulkyinformation har varit ett naturligt inslag i såväl den svenska, norska som finska travsporten under en längre tid och från och med i morgon är det även obligatoriskt att ange i Danmark.</p>



<p class="wp-block-paragraph">Dansk Hestevæddeløb informerar om beslutet i morgondagens banprogram till tävlingarna i Ålborg och där går att läsa <em>”anledningen med registreringen är att servera sportens spelare med relevant information till loppen då denna information kan vara med och höja spelintresset”.</em></p>



<p class="wp-block-paragraph">Anmälan sker enbart digitalt och går inte framföra muntligt på plats på banan. I övrigt gäller samma regler som på svensk mark.</p>



<p class="wp-block-paragraph">I morgon arrangear spelbolaget ATG V5-spel till tävlingarna i Ålborg där två finaler av Grand Circle för treåringar avgörs.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">6 Den delade uppfödningsvinnaren <strong>Bythebook </strong>(e. Googoo Gaagaa) och <strong>Stepping Spaceboy </strong>(e. Dream Vacation) blir de svenska bidragen i Grupp III-loppet Gran Premio Riccardo Grassi (€35.200) i Cesena på lördag.</p>



<p class="wp-block-paragraph">Alessandro Gocciadoro-tränade Bythebook har lottats till spår två bakom bilen och körs av italienske topkusken Roberto Vecchione. Bakom Stepping Spaceboy sitter Marco Stefani</p>



<h2 class="wp-block-heading">Startlista:</h2>



<p class="wp-block-paragraph"><strong>Gran Premio Riccardo Grassi </strong>(€35.200)<br><em>1.660 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Belzebu’ Jet</strong> – Vincenzo Luongo</li>



<li><strong>Bythebook</strong> – Roberto Vecchione</li>



<li><strong>Bonjovi Mmg</strong> – Giampaolo Minnucci</li>



<li><strong>Vesna</strong> – Rene’ Legati</li>



<li><strong>Achille Blv </strong>– Enrico Bellei</li>



<li><strong>Stepping Spaceboy</strong> – Marco Stefani</li>



<li><strong>Chief Orlando</strong> – Filippo Gallo</li>



<li><strong>Akela Pal Ferm</strong> – Antonio Di Nardo</li>



<li><strong>Ziguli Dei Greppi</strong> – Nicola Del Rosso</li>



<li><strong>Zefiro Gual</strong> – Santo Mollo</li>
</ol>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">7 Anette Karlström (Stall Mamsen) kan berätta att ostartade <strong>Eliza Keeper </strong>(e. Credit Winner-Zootsie Keeper) har fått en hingst efter Cool Keeper hos Stall Gustafsberg.</p>



<p class="wp-block-paragraph">– Hon går tillbaka till Cool Keeper, berättar Anette Karlström.</p>



<figure class="wp-block-image alignright size-full"><img src="https://sulkysport.se/wp-content/uploads/2023/07/elizakeeper.jpg" alt="" class="wp-image-466902"/><figcaption class="wp-element-caption">Eliza Keeper med sin son efter Cool Keeper.</figcaption></figure>



<p class="wp-block-paragraph">Tio avkommor har Eliza Keeper sedan tidigare och allra mest utmärker sig Jämtlands Stora Pris-vinnaren <strong>Call Me Keeper</strong> (e. Pine Chip), 1.10,6am*/7.550.503 kr. Samtliga av hennes avkommor i startbar ålder har varit ute och tävlat och tagit 49 vinster på 246 starter.</p>



<p class="wp-block-paragraph">Nämnas kan också trion <strong>Flo Jo Keeper</strong> (e. Broad Bahn), 1.11,8ak/966.500 kr, <strong>Kash Keeper </strong>(e. Uncle Lasse), 1.11,2ak/669.900 kr, och <strong>Alicia Keeper</strong> (e. Conway Hall), 1.13,6ak/443.500 kr.</p>



<p class="wp-block-paragraph">Ni vet väl att ni kan maila in fölrapporter för fri publicering? Uppge mor, far och kön på fölet. Skriv också om ni bestämt vilken hingst stoet ska gå till i år och skicka gärna med en bild.</p>



<p class="wp-block-paragraph"><a href="mailto:claes@sulkysport.se">Maila till Sulkysport</a></p>
