
<p class="has-drop-cap wp-block-paragraph">1 Den svenska unghästsäsongen drar igång på allvar ikväll när den första av nio försöksomgångar till Breeders Crown avgörs i <strong>Örebro</strong> (första start 18.20). Det syns också i startlistorna med gott om storloppsmeriterade ungdomar till start.</p>



<p class="wp-block-paragraph">De fyra främsta i varje försök säkrar plats i semifinalerna på Solvalla den 1 november, medan finalerna som vanligt hålls i Eskilstuna, den 14 november.</p>



<p class="wp-block-paragraph">Hela 21 av kvällens hästar har startat i stora finaler tidigare i karriären och här sticker David Perssons E3-vinnare <strong>Nightlife In </strong>(e. Day Or Night In) och Erlend Rennesvik norska Kriterievinnare <strong>Catchagaga Volo</strong> (e. Googoo Gaagaa) ut, men det finns fler topplaceringar i storlopp för hästarna i BC-försöken i Örebro.</p>



<p class="wp-block-paragraph">Så har har det gått hittills i storloppsfinaler:</p>



<p class="wp-block-paragraph"><strong>Treåriga ston:</strong></p>



<ul class="wp-block-list">
<li><strong>Arizona Trot </strong>(e. Power) – Svampen (trea)</li>



<li><strong>Ballerina </strong>(e. Önas Prince) – Breeders Course tvååringar (oplacerad)</li>



<li><strong>Grace In Heaven</strong> (e. Chapter Seven) – New York Sire Stakes (fyra)</li>



<li><strong>Royal Steel </strong>(e. Muscle Hill) – Svensk Uppfödningslöpning (oplacerad)</li>
</ul>



<p class="wp-block-paragraph"><strong>Treåriga hingstar/valacker:</strong></p>



<ul class="wp-block-list">
<li><strong>Neutron Star </strong>(e. Gimpanzee) – Svensk Uppfödningslöpning (tvåa)</li>



<li><strong>Victorious Tile </strong>(e. Chapter Seven) – Breeders Course tvååringar (trea), Svensk Uppfödningslöpning (fyra), Svampen (sexa)</li>



<li><strong>Thor Tooma </strong>(e. Explosive Matter) – Svensk Uppfödningslöpning (dg), Svampen (dg)</li>
</ul>



<p class="wp-block-paragraph"><strong>Fyraåriga ston:</strong></p>



<ul class="wp-block-list">
<li><strong>Love to the Limit </strong>(e. Bold Eagle) – korta E3 (tvåa)</li>



<li><strong>Global Good News</strong> (e. S.J.’s Caviar) – Breeders Crown (trea), långa E3 (opl)</li>



<li><strong>Catchagaga Volo</strong> (e. Googoo Gaagaa) – Norskt Kriterium (etta)</li>



<li><strong>Gaga Lady </strong>(e. Mister J.P.) – Breeders Course (dg och sexa)</li>



<li><strong>Whammy </strong>(e. Mosaique Face) – långa E3 (opl)</li>



<li><strong>Time to Run</strong> (e. Who’s Who) – Breeders Crown (fyra)</li>
</ul>



<p class="wp-block-paragraph"><strong>Fyraåriga hingstar/valacker:</strong></p>



<ul class="wp-block-list">
<li><strong>You Bow to No One </strong>(e. Nuncio) – korta E3 (sexa), långa E3 (opl), Breeders Crown (opl)</li>



<li><strong>Ruffel </strong>(e. Power) – Svenskt Travkriterium (sexa)</li>



<li><strong>Nightlife In</strong> (e. Day Or Night In) – korta E3 (etta), långa E3 (tvåa), Svampen (fyra), Svensk Uppfödningslöpning (opl), Svenskt Travkriterium (opl)</li>



<li><strong>Lazy Dust </strong>(e. Brillantissime) – Danskt Kriterium (tvåa)</li>



<li><strong>Gangster Vendil </strong>(e. Power) – Breeders Crown (sexa)</li>



<li><strong>Zarex </strong>(e. Readly Express) – Breeders Crown (femma), Svenskt Travkriterium (opl), långa E3 (dg), korta E3 (opl)</li>



<li><strong>Recycle Cash</strong> (e. Ready Cash) – korta E3 (tvåa), Breeders Crown (tvåa)</li>



<li><strong>Barkley </strong>(e. Face Time Bourbon) – Breeders Crown (opl)</li>
</ul>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/04/09v64.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2026/04/09v64.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Breeders Crown-försöken i Örebro.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">2 En hel del intressanta namn har samlats i delningspropositionen upp till 1,5 miljoner kronor vid dagens lunchtävlingar i <strong>Boden</strong> (första start 12.20). Sex lopp har den delats upp i och det finns segervana travare i de flesta.</p>



<p class="wp-block-paragraph">Från lägsta avdelningen, där Jaakko Alamäki-tränade <strong>Waldemar W.F.</strong> (e. Kadett C.D.) redan vunnit tre lopp under 2026, till högsta klassen med Sandra Erikssons <strong>Raven </strong>(e. Bold Eagle) som redan tagit fyra årssegrar på fem försök.</p>



<p class="wp-block-paragraph">I det sistnämnda loppet ställs Raven mot stallkamraten <strong>Kiwi Sisu</strong> (e. Brillantissime), som gör första starten efter issäsongen, och Hanna Olofssons <strong>The Oak L.A. </strong>(e. The Bank). </p>



<p class="wp-block-paragraph"><strong>Bergsåker</strong> (start 17.45) kompletterar som saxbana ikväll och i ett kallblodslopp av god klass gör <strong>Juni Blixt </strong>(e. Tekno Odin), tränad av Jan-Olov Persson, årsdebut efter ett fjolår som innehöll fem starter (2-2-1). Sjuårige Juni Blixt tillhör hästarna som knackar på dörren för att ta sista steget in i eliten med sina 1,5 miljoner på kontot.</p>



<p class="wp-block-paragraph">Bland motståndarna finns Mikael Svingstedt-tränade <strong>Hibovalle </strong>(e. Järvsöviking), som tillhörde landets segerrikaste hästar förra året med åtta triumfer. I år har han inlett med två tredjeplatser.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/04/260409.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2026/04/260409.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">3 Australiens största stjärna <strong>Keayang Zahara </strong>(e. Volstead) är på plats på Nya Zeeland och på fredag startar hon i Tab Trot ($530.000) på Cambridge Raceway.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/02/keayangzaharapic1-617x459.jpg" alt="" class="wp-image-823510"/><figcaption class="wp-element-caption">Keayang Zahara startar på fredag på Cambridge Raceway. Foto Melton</figcaption></figure>



<p class="wp-block-paragraph">Margaret och Paddy Lee åker inte bara med Keayang Zahara till storloppet utan <strong>Jilliby Ballerini </strong>(e. Majestic Son) finns också med på resan, men det är förstås stallets drottning som drar till sig störst uppmärksamhet. Hon jagar sin 28:e seger i 29:e starten i storloppet.</p>



<p class="wp-block-paragraph"><strong>Tab Trot </strong>($530.000)<br>Äldre hästar.<br><em>2.200 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Kusk</strong></p>



<ol class="wp-block-list">
<li><strong>Belle Neige</strong> (e. Love You) – Crystal Hackett</li>



<li><strong>Keayang Zahara</strong> (e. Volstead) – Jason Lee</li>



<li><strong>Ya Rite Darl</strong> (e. What the Hill) – John Dunn</li>



<li><strong>Jilliby Ballerini </strong>(e. Majestic Son) – Glen Craven</li>



<li><strong>Bounce N Beyond </strong>(e. Majestic Son) – vakant</li>



<li><strong>Oscar Bonavena</strong> (e. Majestic Son) – Mark Purdon</li>



<li><strong>Meant To Be</strong> (e. Father Patrick) – Zachary Butcher</li>



<li><strong>Gus</strong> (e. Majestic Son) – Pete McMullen</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">4 Att hästar kombinerar tävling med avel är vanligt i Frankrike. Nu ses en liknande trend i USA, dock i betydligt mindre skala. Kända travare som <strong>Father Patrick</strong> (e. Cantab Hall), 1.08,6*/$2.558.133, och <strong>Mission Accepted</strong> (e. Manofmanymissions), 1.08,4/$1.410.302, har dubbelarbetat.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/06/fatherpatrickstanleylisa-617x374.jpg" alt="" class="wp-image-25278"/><figcaption class="wp-element-caption">Father Patrick både tävlade och användes i avel när han var fyra år gammal. Foto: Lisa Photo</figcaption></figure>



<p class="wp-block-paragraph">Samma väg har passgångaren och Breeders Crown-vinnaren <strong>Gem Quality </strong>(e. Captain Crunch), 1.07,1/$798.187, gått. En annan högaktuell pacer för dubbelarbete är Nancy Takters <strong>Captain Optimistic</strong> (e. Captainreacherous), 1.06,8/$1.136.257.</p>



<p class="wp-block-paragraph">Många minns säkert diskussionerna kring den så kallade ”Gural-regeln”, ett initiativ för att tvinga hingstar att stanna på banan även som fyraåringar genom att begränsa deras avkommors tillträde till vissa storlopp om de pensionerades för tidigt. Regeln var välmenande, men har i praktiken fått utstå kritik för att vara svåradministrerad och orättvis mot hästägare som ville ta sina hingstar till avel.</p>



<p class="wp-block-paragraph">Ett av de största klagomålen inom travsporten är att de största stjärnorna försvinner till avelsboxen alldeles för tidigt. Men i USA växer ett fenomen som kan vara lösningen: hingstar som både tävlar och betäcker under samma säsong. En mer organisk lösning lär ha börjat ta fart.</p>



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



<p class="has-drop-cap wp-block-paragraph">5 Påsken 2026 kommer att gå till historien för travtränaren Thierry Duvaldestin. Under helgen passerade han Jean-Michel Bazires tidigare rekord på 4.016 tränarsegrar. Nu är han den segerrikaste tränaren genom tiderna i Frankrike.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/duvaldesteinclth250126adamstromstalltz-617x409.jpg" alt="" class="wp-image-681988"/><figcaption class="wp-element-caption">Thierry Duvaldestin klappar om sonen Clément efter segern i Prix d&#8217;Amérique. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Det historiska maktskiftet underlättades av att den tidigare rekordhållaren – Jean-Michel Bazire – valde att överlåta tränarrörelsen till sin son Nicolas i slutet av 2024.</p>



<p class="wp-block-paragraph">Thierry Duvaldestins rekordresa har gått i ett högt tempo under våren. Så sent som den 15 mars nådde han den magiska milstolpen 4. 000 segrar på banan i Meslay-du-Maine.</p>



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



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2026/04/lucapeloapr6.jpg" alt="" class="wp-image-835736"/><figcaption class="wp-element-caption">Jordan Stratton tar sin 6.000:e seger. Foto: Mike Lizzi</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6 Jordan Stratton tog sin 6.000:e seger i måndags på Yonkers Raceway när han guidade passgångaren <strong>Lucapelo</strong> (e. Sweet Lou) till vinst på 1.11,2/1.609 meter. Jubileumshästen tränas av Jordans bror Cory.</p>



<p class="wp-block-paragraph">För fem år sedan var Jordan Stratton segerrikaste kusk på Yonkers Raceway och i år placerar han sig som nummer fem. Sitt främsta år hade Jordan 2017 med 394 vinster och över nio miljoner dollar. Noteras kan också att han kört in över 100 miljoner dollar under sin karriär.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 Meslay-du-Maine (första start kl. 11.51) är ensam bana som tävlar i Frankrike idag. Där årsdebuterar Jarmo Niskanen <strong>King Elvis</strong> (e. Bold Eagle) i <a href="https://www.letrot.com/courses/2026-04-09/5307/7" data-type="link" data-id="https://www.letrot.com/courses/2026-04-09/5307/7" target="_blank" rel="noreferrer noopener">Prix Cezanne</a> (€23.000) över 2.875 meter och Joan Melis Macias sköter tömmarna i loppet med 10.350 euro i förstapris.</p>



<p class="wp-block-paragraph">King Elvis har inte vunnit lopp sedan 2023 och det året blev det dubbla triumfer i Argentan och Nancy och båda gångerna satt Joan Melis Macias i sulkyn.</p>



<p class="wp-block-paragraph">Stort slagen som tvåa, men väl en andraplats och 8.750 intjänade euro. Det var facit för Markus B Svedbergs Dee Godfather (e. Father Patrick) i sadelloppet Prix de Marseille (€35.000) igår i Lyon.</p>



<p class="wp-block-paragraph">Dee Godfather serverades en resa i fjärde inner och tog andraplatsen på avstånd. Överlägsen var <strong>Joselito du Vivier</strong> (e. Vittel de Brevol-Paola du Vivier) och från spets var den sjuårige valacken i en klass för sig på 1.13,0/2.850 meter, medan Dee Godfather kom hem på 1.13,8 för Alan Gendrot.</p>
