
<p class="has-drop-cap">1Jörgen Westholms trefaldige storloppsvinnare <strong>Dream Mine</strong> (e. Maharajah) blev förra året den vinstrikaste fyraåringen – tränad på svensk mark – under ett år när han via segern i Breeders Crown-finalen klev upp i 9.179.500 kronor.<br>Dream Mine har behövt tio starter (8-1-1) för att slå <strong>Francesco Zets</strong> (e. Father Patrick) felfria säsong 2022 med nio vinster och nio miljoner kronor på lika många starter.</p>



<p>Dream Mines magiska säsong innehöll blytunga segrar i Svenskt Travderby, Europaderbyt och avslutningsvis Breeders Crown. Samtliga med Mats E Djuse vid tömmarna.<br>När säsongen summerades placerade Jörgen Westholm Dream Mine som den bästa häst han tränat. Den kröntes med att han utsågs till Årets Häst på hästgalan i mars.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/03/dreamminearetshast-617x333.jpg" alt="" class="wp-image-827478"/><figcaption class="wp-element-caption">Jörgen Westholm-tränade Dream Mine tog hästgalans tyngsta titel: Årets Häst. Skärmbild ATG Live</figcaption></figure>



<p>Idag på Umåker (första start 14.35) är Dream Mine tillbaka på tävlingsbanan. Årsdebuten sker i femåringsloppet Berth Johanssons Memorial och tränaren Jörgen Westholm rapporterar om en vinter som gått helt enligt planerna.<br>– Han har haft en jättefin vinter och haft det bra. Han fick ta det lugnt efter Breeders Crown och sedan fick lufsa i snön i två månader i januari-februari. Ifjol behövde han genomköraren i årsdebuten, han satt fast då. Nu är han lite mer jobbad och förberedd, men möter bättre hästar också. Jag vill ha en lång säsong och känner inte att jag måste göra något tokjobb innan han ska årsdebutera, sade Jörgen Westholm till V65 Direkt.</p>



<p>Dream Mine tävlade barfota runt om i fyra starter förra året, vid de tre finalsegrarna och innan dess för första gången i Eskilstunas Fyraåringstest som han också vann.<br>– Han var fantastisk när vi tog av skorna, när han dansade fram i Eskilstuna en tiondel från svenska rekordet, men jag tänker inte nöta på hans fötter nu. Jag vill att han ska vinna, men det här inte årets viktigaste lopp, sade Westholm.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/04/02v85.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Umåkers 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/05/mellbyjinx2-617x333.jpg" alt="" class="wp-image-723131"/><figcaption class="wp-element-caption">Mellby Jinx och Mats E Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">2Nio av tio platser i Paralympiatravets final på Åby den 9 maj med 1,5 miljoner kronor till vinnaren är bokade. En plats återstår och den har vinnaren i eftermiddagens Guldbjörken i Umeå första tjing på. Tackar vinnaren nej bjuds ytterligare en häst in.<br>Umåkers storlopp har dock placerats i skymundan av spelbolaget ATG och placerats som dagens fjärde lopp – utanför V85-spelet. Anledningen – enligt ansvarig på ATG – är att Daniel Wäjersten tränar fyra av åtta hästar.</p>



<p>Finns då vinnaren i Wäjerstens kvartett? Ja, största möjligheten har fjolårets vinnare av ett av Elitloppsförsöken <strong>Mellby Jinx</strong> (e. Ready Cash), som Daniel själv hoppar upp bakom. Mellby Jinx var tvåa i guldfinalen på Solvalla i slutet av mars och en ny topp två-placering tar hästen över elva miljoner kronor insprunget i karriären.<br>Wäjersten har redan två hästar i finalen, titelförsvararen <strong>Borups Victory</strong> och försöksvinnaren <strong>H.C.&#8217;s Crazy Horse</strong>.</p>



<p>Tuffaste utmanaren på Umåker är Daniel Redéns <strong>Double Deceiver</strong> (e. Cantab Hall), som ifjol vann Sweden Cup, S:t Michel Ajo och Jämtlands Stora Pris.</p>



<p>En viktig kugge i Wäjerstens stora stall är förstemannen Oskar Florhed – <a href="https://sulkysport.se/fokus/vilket-lopp-som-helst-med-over-5-000-manniskor-i-publiken/" target="_blank" rel="noreferrer noopener">läs med om Oskari fredagsintervjun här!</a></p>



<p><strong>Klara för Paralympiatravet:</strong></p>



<ul class="wp-block-list">
<li><strong>Borups Victory</strong> (e. Googoo Gaagaa) – titelförsvarare</li>



<li><strong>Francesco Zet</strong> (e. Father Patrick) – inbjuden</li>



<li><strong>Harley Gema</strong> (e. Bold Eagle) – inbjuden</li>



<li><strong>Charron</strong> (e. Code Bon) – inbjuden</li>



<li><strong>Daim Brodda</strong> (e. Readly Express) – inbjuden</li>



<li><strong>Get A Wish</strong> (e. Wishing Stone) – inbjuden</li>



<li><strong>Önas Prince</strong> (e. Chocolatier) – försöksvinnare</li>



<li><strong>H.C.’s Crazy Horse</strong> (e. S.J.&#8217;s Caviar) – försöksvinnare</li>



<li><strong>Kentucky River</strong> (e. Father Patrick) – försöksvinnare</li>
</ul>



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



<p class="has-drop-cap">3Två spikförslag och två skrällar satt klockrent för Sulkysports expertpanel i förra lördagens V85-omgång i Örebro. Nu har experterna laddad om och bland annat faller trycket på Gallium Kronos som spikas av två experter.</p>



<p>Så här säger tränaren Daniel Redén på sin hemsida <a href="http://reddis.se">reddis.se</a> om hästens möjligheter idag:<br>– Gallium Kronos har fungerat bättre som valack och han gjorde det bra i årsdebuten. Jag var dock inte helt nöjd med stilen sista biten och nu har han tränat med en jordbländare och det ser riktigt bra ut. Han fick gå rejält i måndags och höll ihop stilen jättebra. Jag är nöjd med spåret och uppgiften. Samma balans och vagn som senast, säger Daniel Redén.</p>



<p><strong><a href="https://sulkysport.se/spelstugan/v85-tips-u-2-maj/" target="_blank" rel="noreferrer noopener">––> Här är experternas tips till Jägersros V85-omgång.</a></strong></p>



<p><em>Vill du spela andelsspel tillsammans med Sulkysports panel? Här finns olika alternativ:</em></p>



<p><a href="https://www.atg.se/butik/69ansspel/V85_2026-05-02_27_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos 69:ans Spel &#038; Tobak.</a></p>



<p><a href="https://www.atg.se/butik/simsalabim/V85_2026-05-02_27_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Simsalabim.</a></p>



<p><a href="https://www.atg.se/butik/spelpoolen/V85_2026-05-02_27_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Spelpoolen.</a></p>



<p>Travlördagen inleds på svensk mark redan vid lunchtid, då det är tävlingar i Årjäng (första start 12.15). Breddlopp står på menyn på Värmlandsbanan.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/04/260502.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens 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/2024/05/5tangenbork2-617x333.jpg" alt="" class="wp-image-588660"/><figcaption class="wp-element-caption">Tangen Bork. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap"><strong>4Tangen Bork</strong> (e. Bork Odin), 1.18,6ak*/9.190.558 NOK, tränas upp efter knäoperation i slutet av förra året för att försöka vinna Elitkampen för tredje året i rad på Solvalla på Elitloppsdagen. <strong>Mister Hercules</strong> (e. Trixton), 1.09,2ak/7.815.960 kr, lämnade å sin sida Sverige för ett äventyr hos Marcus Melander i USA efter att ha tagit största segrarna hos Daniel Redén i Breeders Crown-final som treåring och Seinäjoki Race tre år senare.</p>



<p>Igår kunde duon glädjas åt samma sak – nämligen första vinnande avkomman på en svensk tävlingsbana!</p>



<p>Tangen Bork har 55 norska och 14 svenskfödda avkommor i sin första treåringskull. Henrik Svensson tränar svenske <strong>Monster Lykken</strong>, som på Dannero kördes till ledningen tidigt och sedan vann i övertygande stil på 1.34,0/2.140 meter. Monster Lykken slutade tvåa i debuten, men behövde bara vönta två vecmor på segern i andra försöket.<br>Dessutom blev det dubbelt upp för Tangen Bork under gårdagen när även norske hingsten <strong>Rondo</strong> segrade på Forus.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/1misterhercules-617x333.jpg" alt="" class="wp-image-722944"/><figcaption class="wp-element-caption">Mister Hercules och Örjan Kihlström vinner det första försöket i Sweden Cup ifjol. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Mister Hercules har betydligtmindre kull att ställa hoppet till. Nio svenska treåringar är födda 2023 och bland dessa finns <strong>Hey There Delilah</strong>, uppfödd och ägs av Rebecca Dahlén och Mona Ström. Rebecca tränar hästen och körde också till vinst i Lindesberg igår. I tävlingsdebuten vann Hey There Delilah från ledningen på 1.18,3/2.140 meter efter ett snabbt slutvarv.</p>



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



<p class="has-drop-cap">5I onsdags imponerade franska Courant-stoet <strong>Lovissime</strong> (e. Love You) i första montéstrten på svensk mark när hon säkrade en plats i Montéeliten på Elitloppsdagen efter seger tillsammans med Jonathan Carre. Huruvida det blir start på Solvalla den dagen återstår att se. Närmast väntar en tur tillbaka till Frankrike med start på Vincennes nästa helg.<br>Redan idag på Vincennes (första start 13.23) startar ett år yngre lillasystern <strong>Mabellissime</strong> (e. Love You) i sulkyloppet Prix de Rennes (€52.000) i andra starten för nye tränaren Sabine Kagebrant. Hästen köptes på Prix d’Amérique-auktionen i januari för 200.000 euro, men galopperade i debuten för den nya ägaren på Solvalla för drygt två veckor sedan.</p>



<p>Fyrfaldige miljonären <strong>Indy Rock</strong> (e. Readly Express) stannade i Frankrike när Daniel Redén slog igen vinterns filial och gick i träning hos Jörgen Westholm. Debuten i nya regin slutade med galopp, men idag tas nya tag i  Prix du Rouergue (€75.000) över 2.100 meter. Alexis Collette sitter i vagnen, precis som i senaste starten, och Indy Rock inleder från spår åtta bakom bilen.</p>



<p>Tre av Vincennes lopp är öppna för europeiska hästar och i Prix de Garabit (€59.000) över 2.100 meter med bilstart finns svenskfödda trion <strong>Mister Invictus</strong> (e. Ready Cash), <strong>Donizetti</strong> (e. Maharajah) och <strong>Junkie</strong> (e. Varenne) – samtliga i fransk träning – med i startlistan.</p>



<p><a href="https://www.letrot.com/courses/programme/2026-05-02/7500" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar på Vincennes.</a></p>



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



<p class="has-drop-cap">6Femårige valacken <strong>Fighter Kronos</strong> (e. Muscle Hill), 1.11,6ak/1.640.470 kr, vann försök till Svenskt Travderby förra året och slutade sexa i finalen trots galopp. Detta i regi Jerry Riordan/Ingrid Bengtsson. Efter sjundeplatsen i silverdivisionsfinalen på Solvalla i början av februari flyttades hästen till Frankrike och gick i träning hos dansken Erik Bondo. Efter två galoppmissar i inledningen pånymark har femåringen radat upp tre raka tredjeplatser, varav två på Vincennes.</p>



<p>Nu är hästen till salu. Fighter Kronos är med som ett av 16 nummer i den digitala katalogen till kvällens auktion hos Travera.</p>



<p>Fighter Kronos har gjort 41 starter (7-3-8) och förutom Derbykval vann han Kriterierevanschen och E3-revansch i slutet av treåringssäsongen.</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/0m3a4534-617x412.jpg" alt="" class="wp-image-714828"/><figcaption class="wp-element-caption">Imperator F.I. och Örjan Kihlström. Foto: Terhi Piispa-Helisten</figcaption></figure>



<p class="has-drop-cap">7Unga finska tränaren Hanna Lepistö gjorde en svensk satsning under hösten och vintern och avrundade snyggt med tre segrar på de nio sista starterna i januari-februari. Det är i Finland hon annars har verksamheten och året har inletts med succé. Eller vad sägs om 19 segrar och tolv andraplatser på 55 starter hittills under 2026?<br>I onsdags vann Hannas <strong>Diamond Truppo</strong> (e. Varenne) på 1.10,0a/1.620 meter på Vermo och belönades med en biljett till Finlandia-Ajo (€190.000) den 10 maj.</p>



<p>I dagens gulddivisionslopp i Uleåborg, Number One med 10.000 euro i förstapris, tar Hanna ut ett spännande nyförvärv i finskfödde <strong>Imperator</strong> (e. Maharajah). Hästen återvände till Finland i slutet av förra året efter knappt två år i Daniel Redéns regi. Största framgången i Redéns träning kom i finska S:t Leger 2004, där Imperator slutade tvåa bakom Elitloppshästen <strong>Massimo Hoist</strong> (e. Muscle Hill).<br>Nu gör Imperator första starten efter nästan halvårslångt uppehåll och har dragit sjundespår bakom bilen i sprinterloppet.</p>



<p>Imperator tränades även i början av karriären av Johan Untersteiner.</p>



<p><strong>Startlista Number One</strong><br>1.620 meter autostart, Uleåborg lördag<br><em>Häst(far) – Kusk</em></p>



<ol class="wp-block-list">
<li><strong>Consalvo</strong> (e. Ready Cash) – Juha Utala</li>



<li><strong>Lake’s Action</strong> (e. Citation Lindy) – Niko Jokela</li>



<li><strong>Astrum</strong> (e. Lexus Font) – Antti Veteläinen</li>



<li><strong>Vincent Vici</strong> (e. Orlando Vici) – Tuukka Varis</li>



<li><strong>Corazon Combo</strong> (e. Express Duo) – Pekka Korpi</li>



<li><strong>Icella</strong> (e. Maharajah) – Veli-Pekka Toivanen</li>



<li><strong>Imperator</strong> (e. Maharajah) – Santtu Raitala</li>



<li><strong>Time Match</strong> (e. Maharajah) – Ville Pohjola</li>



<li><strong>Callela Nelson</strong> (e. Beer Summit) – Hannu Torvinen</li>



<li><strong>Piece of Hero</strong> (e. Zola Boko) – Jani Routsalainen</li>
</ol>

Fokustema
Sju nyheter vid sju
Läs senare
”Inte årets viktigaste lopp”
Westholm om formen för Dream Mine. Sista chansen till Paralympiatravet. Vad har Mister Hercules och Tangen Bork gemensamt? Courants tvåmiljonersköp tillbaka på Vincennes. Fjolårets Derbysexa säljs på auktion.
Detta och mer bland lördagens nyheter.
Detta och mer bland lördagens nyheter.
