
<p class="has-drop-cap">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>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>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/03/brionijlelitloppet2011-617x333.jpg" alt="" class="wp-image-830848"/><figcaption class="wp-element-caption">Brioni och Joakim Lövgren vann Elitloppet 2011. Foto Stalltz.se</figcaption></figure>



<p><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 <strong>Viola Silas</strong> (Fredrik Persson) 1.10,9 – Ej med i Elitloppet</li>



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



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



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



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



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



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



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



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



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



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



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



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



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



<li>2025 <strong>Global Etalon</strong> (Fredrik Wallin) 1.10,5 – Ej med i Elitloppet</li>
</ul>



<p><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">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/6mellbyjinx1-617x333.jpg" alt="" class="wp-image-723130"/><figcaption class="wp-element-caption">Mellby Jinx och Mats E Djuse vann på nytt svenskt rekord i Elitloppsförsöket. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">2I år har Gävles storlopp tappat direktbiljetten till Elitloppet, men likväl finns chansen att vinnaren får plats i Elitloppet om tolv dagar. Prins Daniels lopp är mdetg sjunde och sista i nya E-loppsserien, där två platser i Elitloppet ligger i potten. Den ena har <strong>Don Fanucci Zet</strong> (e. Hard Livin) redan säkrat, men kampen om den andra lever.</p>



<p><strong>Francesco Zet</strong> (e. Father Patrick) och <strong>Barack Face</strong> (e. Ready Cash) har vunnit varsitt försök och delar andraplatsen, men båda hästarnas tränare har deklarerat att Elitloppet inte är aktuellt.</p>



<p>Då öppnas dörren för lördagens vinnare, eller Daniel Wäjerstens <strong>Mellby Jinx</strong> (e. Ready Cash) om denne slutar sämst tvåa. Då blir han också tvåa i E-loppsserien. <strong>High On Pepper</strong> (e. Ready Cash) och <strong>Kentucky River</strong> (e. Father Patrick) har samlat ihop sex poäng vardera, men det kräbs vinst för att ta sig förbi hästar som vunnit i E-loppsserien.<br>Hamnar flera hästar på samma poäng går platsen till den häst med flest starter. I annat fall sker lottning.</p>



<p>Fem hästar har kvalat in via vårens gulddivisionsförsök – <strong>H.C.’s Crazy Horse, Kentucky River, Luke the Spook, Mellby Jinx</strong> och <strong>Mellby Joker</strong>. Övriga fem platser har tillsatts genom wildcards som gått till <strong>Diamond Truppo, Global Etalon, High On Pepper, Keep Asking</strong> och <strong>Powwow</strong>.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/05/23v85.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Gävles V85-tävlingar.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/09/teklahesteguiden-617x333.jpg" alt="" class="wp-image-769252"/><figcaption class="wp-element-caption">Tekla och Sandra Eriksson hade lekstuga i Stokriteriet på Bjerke och blev enda svenska vinnare i kallblodens klassiker 2025. Foto Hesteguiden.com</figcaption></figure>



<p class="has-drop-cap">3Sandra Erikssons kallblodstalang <strong>Tekla</strong> (e. Tekno Odin) hade en fin treåringssäsong ifjol med triumfen i Stokriteriet på Bjerke som höjdpunkt. Totalt blev det fem segrar på nio starter.</p>



<p>Årsdebuten hemma i Boden i slutet av mars lämnade frågetecken efter sig när Tekla var tidigt slagen efter att ha körts till ledning. Dessa rätades ut sex veckor senare när hon efter smygresa spurtade piggt mot äldre konkurrenter. Tekla kom hem 1.24,5a/1.640 meter, svenska rekordet är 1.24,3a, noterat av <strong>Gullan Fax</strong> (e. Järvsöfaks för 22 år sedan!</p>



<p>Ikväll var tanken att starta i ett Sleipner Cup-försök för fyraåriga ston i Skellefteå (första start 18.20), men Tekla var den enda häst som anmäldes. Istället blir det åter att möta äldre hästar i ett dubbelklasslopp med fördel ston, där Tekla startar från 20 meters tillägg. Där sticker duktiga ston ut, som <strong>M.P.Flora, Mira Kiro, Teknolina, Ängspuma</strong> och <strong>Lia Lykke</strong>.</p>



<p>Loppen är namngivet Jan Åbergs Minne och Jan var en stor kallblodsälskare och framgångsrik uppfödare. Hans främsta kort är svenske mästaren från 1996, <strong>Bodbäckspålle</strong> (född 1989 e. Pål Best), 1.22,3ak/2.125.214 kr. Bodbäckspålle vann 42 lopp i Stig Lindmarks regi.<br>Jan Åberg tilldelades kallblodsorganisationen Sleipners guldnål 2010, men gick bort i slutet av samma år. Det året föddes också en blivande klassisk vinnare hos Åberg i <strong>Bodbäckssiv</strong> (e. Briskeby Philip), som segrade i Derbystoet i Östersund 2014 med sin tränare Jessica Lindgren i vagnen.</p>



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



<p class="has-drop-cap">4Tre hästar har vunnit i båda sina starter på Gotland i vår. När Visby (första start 12.20) är dagens lunchbana kan en av dem gå upp i ensam ledning, nämligen Fredrik Gränefjord-tränade <strong>Marlon Brandy Sisu</strong> (e. Don Fanucci Zet).</p>



<p>Marlon Brandy Sisu inledde tävlingskarriären med nio starter utan en enda pallplats men en hel del galopper som två- och treåring. Nu som fyraåring är han hundraprocentig efter två starter.<br>Båda vinsterna har tagits med flera längder på 1.16,7a/2.140 meter. Samma förutsättningar gäller i dagens lopp, där Stefan Persson tar plats i vagnen.</p>



<p>Kvällen kompletteras med breddlopp i Bollnäs (första start 17.45). </p>



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



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/11/eyeofthetiger1-617x333.jpg" alt="" class="wp-image-791766"/><figcaption class="wp-element-caption">Eyeofthetiger och Per Nordström. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">52024 satte han svenskt rekord med fyra tiondelar när han vann försök till Svensk Uppfödningslöpning på 1.12,0a/1.640 meter. Däremot blev det galopp i finalen. Totalt blev det fyra segrar på sex starter och intrycket var så starkt att hästen utsågs till Årets tvååring i Sverige.</p>



<p>Fjolårets treåringssäsong blev dock inte alls vad man hoppats på för Per Nordström-tränade <strong>Eyeofthetiger</strong> (e. Django Riff), 1.12,0ak*/878.250 kr. Hästen galopperade i ledning i Breeders Course-finalen på Elitloppdagen, där dåvarande stallkamraten Wise Guy (e. Face Time Bourbon) vann på världsrekord.</p>



<p>Det blev bara en start till som treåring – fyra i ett vanligt treåringslopp på Jägrsro – men på fredag inleder Eyeofthetiger en ny säsong. Det sker i ett försök i Kalmars fyraåringsserie och Eyeofthetiger inleder från 40 meters tillägg.</p>



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



<p class="has-drop-cap">6Två försök i Breeders Course (€10.000) för treåringar hålls på San Siro i Milano (första start kl. 14.30) idag och de två främsta från varje försök går vidare till finalen på Solvalla under Elitloppssöndagen. </p>



<p>Alessandro Gocciadoro brukar ladda för Breeders Course och i hingstavdelningen plockar han ut Invictus Bar (e. Maharajah), medan In the Night Gar (e. Victor Gio) i stonas uppgörelse.</p>



<p>I de fyra försök som körts i Sverige på Jägersro respektive Solvalla är vinnarna Revanche Boko (e. Face Time Bourbon) och Mister Navajo (e. Muscle Hill) på hingstsidan, medan Cruiser (e. Calgary Games) och Ruby Newport (e. Maharajah) vunnit i stolklassen.</p>



<p><strong>Startlistor Breeders Course (€10.000)</strong><br><strong>Treåriga ston, 2.100 meter autostart.<br></strong><em>Häst (far) – Körsven</em></p>



<ol class="wp-block-list">
<li><strong>Iside Dany Bar</strong> (e. Nad al Sheba) – Marco Stefani</li>



<li><strong>In the Night Gar</strong> (e. Victor Gio) – Alessandro Gocciadoro</li>



<li><strong>Intesa Ek</strong> (e. Face Time Bourbon) – Andrea Guzzinati</li>



<li><strong>Immensia</strong> (e. Greenshoe) – Pietro Gubellini</li>



<li><strong>Independent Gar</strong> (e. Father Patrick) – Manuel Pistone</li>



<li><strong>Ira dei Bar</strong> (e. Calgary Games) – Edoardo Loccisano</li>
</ol>



<p><strong>Treåriga hingstar, 2.100 meter autostart.</strong><br><em>Häst (far) – Körsven</em></p>



<ol class="wp-block-list">
<li><strong>I Feel Good Bi</strong> (e. Bar Hopping) – Manuel Pistone</li>



<li><strong>Indigo Roc</strong> (e. Nad al Sheba) – Filippo Rocca</li>



<li><strong>Invictus Bar</strong> (e. Maharajah) – Alessandro Gocciadoro</li>



<li><strong>Italo Jet</strong> (e. Maharajah) – Pietro Gubellini</li>



<li><strong>Icaro Degli Dei</strong> (e. Calgary Games) – Marco Stefani</li>
</ol>



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



<p class="has-drop-cap">7Finske tränaren Antti Ojanperä, 44, nådde en milstolpe som tränare i söndags – och det var en bra bit från den stora scenen. När hans kallblodskung och Elitkampsvinnare <strong>Evartti</strong> (e. K.M.Nopsa) tog hem 150 euro vid en typ av lokaltävlingar på hemmabanan Pihtipudaa var det finländarens seger 1.000 i tränarkarriären. I segersulkyn satt sambon Jutta Ihalainen.</p>



<p>För Evartti var det första starten sedan i midsomras, då han galopperade i Nordic King i Härmä.<br>– Tidigt i min karriär trodde jag att det skulle vara ett bra mål att nå tusenklubben som kusk. Då tänkte jag inte så mycket på saker som att träna häst. För ungefär tio år sedan slutade jag köra och har mest fokuserat på att vara tränare istället, säger Antti Ojanperä till MT Hevoset.</p>



<p>Ojanperä har utsetts till Årets tränare i Finland tre gånger, däribland de två senaste åren.</p>
