
<p class="has-drop-cap wp-block-paragraph">1Sedan premiäråret 2011 har en häst lyckats att knipa Elitloppsbiljetten via seger i Prins Daniels lopp i Gävle – och följa upp med triumf på Solvalla åtta dagar senare, nämligen Robert Bergh-tränade <strong>Nahar</strong> (e. Love You) för elva år sedan.</p>



<p class="wp-block-paragraph">Ytterligare en Elitloppsvinnare har även vunnit Prins Daniels lopp, men inte samma år. När Joakim Lövgrens <strong>Brioni</strong> (e. Timberland) triumferade på Solvalla 2011 hade han en fjärdeplats i bagaget i Gävle åtta dagar tidigare. Istället vann Brioni Prins Daniels lopp året efter, då han senare slutade oplacerad i Elitloppsfinalen.</p>



<p class="wp-block-paragraph">Fyra hästar har kvalat in via vårens gulddivisionsförsök – <strong>Kentucky River, Castor the Star, Mellby Joker</strong> och <strong>Thereisnolimit</strong>. Övriga sex platser har tillsatts genom wildcards som gått till <strong>Bedazzled Sox, Crepe Match, Decision Maker, Double Deceiver, Global Etalon</strong> och <strong>Lozano di Quattro</strong>.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/05/17v75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens V75-tävlingar i Gävle.</a></p>



<p class="wp-block-paragraph"><strong>Här är vinnarna i Prins Daniels lopp/gulddivisionsfinalen och hur de presterat i Elitloppet:</strong><br><em>År Häst (tränare) Tid – Resultat i Elitloppet</em></p>



<ul class="wp-block-list">
<li>2011 Viola Silas (Fredrik Persson) 1.10,9 – Ej med i Elitloppet</li>



<li>2012 Brioni (Joakim Lövgren) 1.09,8– Tvåa i försöket, oplacerad i finalen</li>



<li>2013 Nahar (Robert Bergh) 1.09,7 – Tvåa i försöket, vinnare i finalen</li>



<li>2014 Truculent (Lars I Nilsson) 1.09,5 – Utslagen i försöket</li>



<li>2015 Mosaique Face (Lutfi Kolgjini) 1.09,0 – Trea i försöket, tvåa i finalen</li>



<li>2016 Volstead (Stefan Melander) 1.09,8 – Utslagen i försöket</li>



<li>2017 Workout Wonder (Jarno Kauhanen) 1.10,0 – Ej med i Elitloppet</li>



<li>2018 Heavy Sound (Daniel Redén) 1.09,2 – Ej med i Elitloppet</li>



<li>2019 Sorbet (Daniel Redén) 1.10,2 – Utslagen i försöket</li>



<li>2020* Racing Mange (Joakim Lövgren) 1.09,7 – Tvåa i försöket, sexa i finalen</li>



<li>2021 Gareth Boko (Jerry Riordan) 1.09,6 – Trea i försöket, trea i finalen</li>



<li>2022 Click Bait (Stefan Melander) 1.10,5 – Tvåa i försöket, femma i finalen</li>



<li>2023 Mister Hercules (Daniel Redén) 1.09,7 – Utslagen i försöket</li>



<li>2024 Stoletheshow (Frode Hamre) 1.09,7 – Ej med i Elitloppet</li>
</ul>



<p class="wp-block-paragraph"><em>* Under coronapandemin 2020 kördes loppet som en vanlig gulddivisionsfinal och inte under namnet H.K.H. Prins Daniels lopp.</em></p>



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



<p class="has-drop-cap wp-block-paragraph">2Den 11 juli avgörs kvalen till Stochampionatet, vars final körs nio dagar senare på Axevalla. Ikväll (första start 18.20) värmer Stochampionatsbanan upp ytterligare inför årets höjdpunkt på Skaraslätten när de fyraåriga stona får chansen att prova den långa distansen igen i andra testet till Stochampionatet.</p>



<p class="wp-block-paragraph">Det första kördes i mitten av mars med nybakade Drottningspokalvinnaren <strong>Panthere d&#8217;Inverne</strong> (e. Brillantissime) i segerroll. Kan någon av kvällens åtta deltagare ta samma kliv på utvecklingskurvan som Panthere d&#8217;Inverne efter det här testet?</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/mariatornqvistdwightpieters-617x333.jpg" alt="" class="wp-image-683401"/><figcaption class="wp-element-caption">Maria Törnqvist och Dwight Pieters. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Paul Hagoorts <strong>Bourbonnista</strong> (e. Face Time Bourbon) är favorit när hon jagar femte segern i tolfte försöket. Minst rutinerad bland motståndarna är årsdebuterande <strong>Magnitize Me</strong> (e. Maharajah) med blott fem starter (2-1-1) innanför västen och 116.500 kronor på bankboken.<br>– Magnitize Me är en riktigt fin märr, rent ut sagt en topphäst. Jag tycker att det är en årgångshäst och visst finns det funderingar på Stochampionatet, så det känns rätt att testa här även om det är hårt emot, säger Maria Törnqvist i Axevallas banprogram.</p>



<p class="wp-block-paragraph">Andra testet tar också plats på V64-kupongen, där det är jackpot med extra pengar i sexrättspotten även ikväll.</p>



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



<p class="has-drop-cap wp-block-paragraph">3Det tävlas flitigt på svensk mark idag och totalt är fyra banor igång. Det inleds med lunchtävlingar i Skellefteå (start 12.20), där ett sprinterlopp som avslutar V4-omgången håller riktigt god klass.</p>



<p class="wp-block-paragraph"><strong>Dutchess Sun</strong> (e. Maharajah) vann både stofinal under Elitloppshelgen och Norskt Mästerskap för ston förra året. I år är hon fortsatt segerlös när Daniel Wäjerstens sto den här gången får Oskar Flodhed i vagnen.<br>Bland motståndarna finns kapabla travare som Petri Salmelas amerikanska nyförvärv <strong>Robinhood C.A.</strong> (e. Walner), <strong>Swagger</strong> (e. Zola Boko), <strong>Maybach W.F</strong>. (e. Maharajah) och <strong>Beacon Kronos</strong> (e. Father Patrick).</p>



<p class="wp-block-paragraph">På Jägersro (start 18.30) årsdebuterar Per Nordström fyraårige <strong>Bootsman</strong> (e. Campo Bahia) mot äldre hästar över lång distans. Efter att ha gjort bort sig med galopp i debuten som tvååring radade Bootsman upp sex raka segrar innan sviten bröts i Sommarfavoriten genom andraplatsen bakom August Zonett (e. Pojke Kronos). Nu väntar första starten sedan Breeders Crown-semifinalen i november.</p>



<p class="wp-block-paragraph"><strong>Hidalgo Heldia</strong> (e. Raja Mirchi) har vunnit både Breeders Crown i Tyskland och i silverdivisionen, men nu kliver hästen – som sedan november tränas av Tiina Kaunisaho – ned i klass rejält när han dyker upp i breddlopp i Eskilstuna (start 17.45).</p>



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



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



<p class="has-drop-cap wp-block-paragraph">4Tvåa och trea i Elitkampen förra året, men kanske ingen start 2025? Gunnar Melander har gett avslag med <strong>Månlykke A.M.</strong> (e. Månprinsen A.M.), som inte startat sedan han slutade tvåa i Gävle på skärtorsdagen och kollades upp av veterinär efteråt.<br>– När förberedelserna blir fel så blir det inte rätt mot någon, det är en sådan fin häst. Vi tar sikte mot resten av säsongen istället. Nu tränar vi på igen, men det tar ett tag innan vi kommer ut igen när det blev hack i skivan, säger Gunnar Melander till <a href="https://www.travronden.se/travsport/travtavling/kallblodslopp/a/gunnar-melander-om-manlykke-amblev-hack-i-skivan" target="_blank" rel="noreferrer noopener">Travronden</a>.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/06/manlykkea.m.2024-617x333.jpg" alt="" class="wp-image-599068"/><figcaption class="wp-element-caption">Gunnar Melander och Månlykke A.M. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Antti Ojanperä-tränade <strong>Evartti</strong> (e. K.M.Nopsa) vann Elitkampen 2023 och slutade tvåa ifjol. I lördags fick hästen en biljett till årets upplaga, men tränare Ojanperä är orolig efter hästens start i Forssa i fredags. Då gav han upp helt från ledningen och blev rejält akterseglad. Hästen kollades upp av veterinär och blodprov togs i helgen.<br>– Veterinärundersökningarna fann ingen faktor som förklarar insatsen och de första blodprovsresultaten visade inte heller några avvikelser. Kroppen fungerade helt enkelt inte ordentligt. Vi kommer att ta fler prov och får se hur hästen mår. Jag känner ingen press om Elitkampen och vi åker bara om allt är bra med Evartti, säger Ojanperä till <a href="https://www.maaseuduntulevaisuus.fi/hevoset/25ef906a-8c74-42b1-8654-54c8b5ab8d86" target="_blank" rel="noreferrer noopener">Ravinetti</a>.</p>



<p class="wp-block-paragraph"><strong>Klara för Elitkampen 2025</strong><br><em>Häst (far) – Land – Tränare</em></p>



<ul class="wp-block-list">
<li>B.W.Sture (e. Moe Odin) – Sverige – Jan-Olov Persson</li>



<li>Evartti (e. K.M.Nopsa) – Finland – Antti Ojanperä</li>



<li>Oppgårdsdrängen (e. Tekno Odin) – Sverige – Jan-Olov Persson</li>



<li>Stallone (e. Frans) – Finland – Antti Ojanperä</li>



<li>Tangen Bork (e. Bork Odin) – Norge – Öystein Tjomsland</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">5På tal om Elitkampen…Merete Viksås är tydlig med att hon vill till Solvalla med sin segermaskin <strong>Stumne Fyr</strong> (e. Joker Elden), som missade chansen till en direktbiljett när han slutade trea i Bollnästravets Elitsprint. Men om hästen inte skulle få en inbjudan till Solvalla av Anders Malmrot har han så gott om startpoäng att han lär komma med i loppet ändå.</p>



<p class="wp-block-paragraph">Matchningen mot Solvallastart fortsätter ikväll på Bjerke, där Stumne Fyr startar i snabbloppet för kallblod med 30.000 kronor i förstapris. Loppet avgörs över medeldistans och Stumne Fyr har en straffspark på papperet tillsammans med Ole Johan Östre när han ställs mot sju konkurrenter.</p>



<p class="wp-block-paragraph"><a href="https://www.travsport.no/travbaner/bjerke-travbane/startlist/2025-05-13" target="_blank" rel="noreferrer noopener">Här är startlistorna till Bjerkes tävlingar ikväll.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/0m3a1221-617x412.jpg" alt="" class="wp-image-714668"/><figcaption class="wp-element-caption">Santtu Raitala och Lightning Stride vann enkelt Arvid Åvallin Tammaderby från spets häromveckan. Photo: Terhi Piispa-Helisten</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6Katja Melkko-tränade stoet <strong>Lightning Stride</strong> (e. Twister Bi) slog hingstarna i finska Derbyt förra året och vann även Villinmiehen Tammakilpa (€92.400). För 1,5 veckor sedan plockade hon hem Arvid Åvallin Tammaderby (€43.000) på Vermo och nu har planerna lagts upp för sommaren.</p>



<p class="wp-block-paragraph">Närmast väntar Killerin Eliitti (€52.500) i Jyväskylä den 7 juni med 25.000 euro till vinnaren. Loppet är öppet för fyra- och femåringar över medeldistans. Sommarens stora mål är annars S:t Michel Ajo i Mikkeli i juli.<br>– Hon har återhämtat sig bra efter Tammaderby och Killerin Eliitti är ett lämpligt lopp på vägen mot S:t Michel, säger Katja Melkko till <a href="https://www.maaseuduntulevaisuus.fi/hevoset/254563a0-9809-481c-9a08-44e393c403d5" target="_blank" rel="noreferrer noopener">Ravinetti</a>.</p>



<p class="wp-block-paragraph">Förutom Lightning Stride är svenskfödde <strong>Star Photo S.</strong> (e. Classic Photo), <strong>Vincent Vici</strong> (e. Orlando Vici) och <strong>Sahara Commander</strong> (e. R.C.Royalty) inbjudna till Jyväskylä.</p>



<p class="wp-block-paragraph">Lightning Stride har gjort 30 starter (11-2-2) och sprungit in 3,3 miljoner hittills.</p>



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



<p class="has-drop-cap wp-block-paragraph">7Enbart lopp för franskfödda hästar står på kvällens meny på Vincennes (första start 16.32) och enda blågula inslaget är Jarmo Niskanen. Denne plockar ut treårige <strong>Macbeth</strong> (e. Gu d’Heripre) i Prix de Saumur (€40.000) över 2.700 meter med 18.000 euro till vinnaren.</p>



<p class="wp-block-paragraph">Gabriele Gelormini sitter i vagnen bakom hästen som inlett karriären fint med andraplats i debuten i Le Croise-Laroche och seger i Prix de Housset (€18.000) i La Capelle i andra starten.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2025-05-13/" target="_blank" rel="noreferrer noopener">Här är startlistorna till Vincennes tävlingar.</a></p>

Fokustema
Sju nyheter vid sju
Läs senare
Läge att göra en ”Nahar” igen?
Från Prins Daniels lopp till Elitloppet – så har det gått. Fyraåriga ston testar Stochampionatsdistansen. BC-vinnare i breddlopp. Läget med två kallblodsstjärnor. Matchningen klar för Derbyvinnare.
Detta och mer bland tisdagens morgonnyheter.
Detta och mer bland tisdagens morgonnyheter.
