
<p class="has-drop-cap wp-block-paragraph">1Daniel Redén har redan två hästar i Elitloppet. Vinner <strong>Double Deceiver</strong> (e. Cantab Hall) blir det tre. En rosa biljett ligger i potten i Prins Daniels Lopp i Gävle (första start 14.45) idag. Den sexårige valacken, som kostade 500.000 dollar på Harrisburgs mixedauktion som treåring, har bara gjort elva starter på svensk mark och vunnit sju av dessa. Närmast kommer han från femteplatsen i Finlandia-Ajo.<br>– Jag tror att formen är riktigt bra. Loppet han gör på ett för honom ganska opassande bana i Finland var väldigt, väldigt bra. Normalt borde min häst tacka för sig och lyftas ut med lyftkran, men han hade ytterligare en liten halvspeed till slut och kämpar sig i mål som femma. Hans inställning är det bästa, han är så speciell i humöret. Han ska bestämma och inte kusken, sade Daniel Redén till V65 Direkt.</p>



<p class="wp-block-paragraph">Utmanarna då? Ja, Per K Eriksson har försäljningsplaner med <strong>Lozano di Quattro</strong> (e. Trixton) och den så meriterade Mantorptränaren – med tre Hambletoniansegrar på meritlistan genom Prakas, Giant Victory och Alf Palema – är förhoppningsfull när Carl Johan Jepson kör för första gången. <br>– Vi kommer att beställa en extra bilprovstart så att Jepson får känna på honom bakom bilen. Inte bara för att han ska kunna ta ledningen, utan för att han ska känna vad han har i tömmarna. Han är relativt startsnabb men att bli en katapult finns inte i honom. Jag tror att formen är på vägupp och bra och han känns bra i träning efter loppet. Det är en stenhård rackare i ben och psyke, det är en riktig tävlingshäst, sade Per Eriksson till V65 Direkt.</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 dagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">2Gunnar Wallberg var 15-faldig kuskchampion på hemmabanan Gävle 1956-1972 och han hedras med ett minneslopp för kallblod: dubbelcupfinalen med lördagens näst högsta prischeck: 200.000 kronor.</p>



<p class="wp-block-paragraph">Gunnar firade framgångar med hästar av båda raserna, men på hösten 1967 skrev han historia när <strong>Solels</strong> (e. Solo) blev första svenska kallblod att trava under 1.30 i voltstart.<br>Första segern tog Wallberg med pappa Göstas Rexie Blank och totalt blev det 1.058 kusksegrar sedan han klivit in i ”tusenklubben” 1984 efter seger på hemmaplan med Mr Vanadis. Bland duktiga travare från karriären kan Farga, Lugano, Morris, Tom Brunnby och Stochampionatsvinnaren Sweet Janki nämnas.<br><em>”För Gunnar var arbete och åter arbete mottot under alla år. Gunnar var en man med höga krav på sin omgivning och att arbeta åt honom var förenat med att man hela tiden visste att de här kraven fanns. Gunnar var hård, men alltid rejäl och även om han hade höga krav på andra så hade han alltid de högsta kraven på sig själv,” </em>beskrivs Gävles mångfaldige champion i banprogrammet till dagens tävlingar.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/02/gunnarmelander22-617x333.jpg" alt="" class="wp-image-411640"/><figcaption class="wp-element-caption">Gunnar Melander. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Dagens final ser en annan stor, svensk travprofil i fokus, 78-årige Gunnar Melander som mönstrar segermaskinen <strong>Guldhagens Oscar</strong> (e. Månprinsen A.M.). Gunnar körde själv hästen till seger i genrepet och i eftermiddagens uppgift kliver Guldhagens Oscar ut med fem raka segrar tillsammans med Magnus A Djuse.</p>



<p class="wp-block-paragraph">Hur tänker Sulkysports tipsexpert om loppet? <a href="https://sulkysport.se/spelstugan/v75-tips-13/" target="_blank" rel="noreferrer noopener">Här är hela tipsgenomgången till V75 med analyser, spikar, drag och systemförslag.</a></p>



<p class="wp-block-paragraph">Hos vår samarbetspartner Travnet finns andelar till dagens V75-omgång på Högkvarteret.<br><a href="https://www.atg.se/hogkvarteret/V75_2025-05-17_16_5" target="_blank" rel="noreferrer noopener">Här är alla andelar!</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/2023/05/queenbelinabctacke-617x333.jpg" alt="" class="wp-image-444720"/><figcaption class="wp-element-caption">Jörgen Westholm-tränade Queen Belina iförd segertäcket från Breeders Crown-finalen för treåriga ston. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3Sexåriga toppstoet <strong>Queen Belina</strong> (e. Nuncio), 1.10,1ak/5.241.000 kr, lägger tävlingsskorna på hyllan. Hon tävlade hela karriären för Jörgen Westholm – även uppfödare tillsammans med Anders Karlsson, Ekeby Gård – och ägdes av Anders van Dapperen HB, Mellbystrand. Detta rapporterar <a href="https://www.travronden.se/travsport/djurskotsel/avel/a/queen-belina-slutar-tavla" target="_blank" rel="noreferrer noopener">Travronden</a>.</p>



<p class="wp-block-paragraph">Totalt gjorde Queen Belina, som är döpt efter fuxiga Prix d’Amérique-vinnarna Queen L. och Belina Josselyn, 34 starter (9-3-8) och tyngst väger segrarna i Breeders Crown både som tre- och fyraåring. Queen Belina slutade även trea i Svenskt Trav-Oaks, fyra i Derbystoet och var även finalist i Stochampionatet.</p>



<p class="wp-block-paragraph">Queen Belina är på plats i Frankrike för att betäckas med italienske fyraåringen <strong>Frank Gio</strong> (e. Face Time Bourbon).<br>– Face Time Bourbon låg närmast till hands men det gick inte med så kort varsel. Då blev det en son till honom istället som har börjat lovande på tävlingsbanan, säger Anders Karlsson till Travronden.</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/2024/09/periculum23182024nicholasbarnsdalephoto-617x411.jpg" alt="" class="wp-image-628650"/><figcaption class="wp-element-caption">Periculum vid vinst i Maple Leaf Trot. Foto Nicholas Barnsdale Photo</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4Årets andra storlopp för äldre travare – Arthur J. Cutler Memorial ($158.000) – hålls på Meadowlands i natt. <br>Fyra svensktränade travare kommer till start. Från Marcus Melanders stall selas Muscle Hill-sönerna <strong>Periculum</strong> och <strong>Oh Well</strong> ut, medan Nancy Takter startar <strong>Hasty Bid</strong> (e. My MVP) och Åke Svanstedt sänder ut danskfödde <strong>Get A Wish</strong> (e. Wishing Stone) till start. </p>



<p class="wp-block-paragraph">Arthur J. Cutler Memorial har körts sedan 1998 och två år senare kom den förste svensktränade vinnaren. Då vann Berndt Lindstedt med <strong>Kick Tail</strong> (e. Sierra Kosmos) och sedan har det blivit ytterligare nio vinster och senast Åke Svanstedt-tränade <strong>Jiggy Jog </strong>(e. Walner) ifjol.<br><strong>Ecurie D</strong> (e. Infinitif) har löpningsrekordet med 1.07,9.</p>



<p class="wp-block-paragraph"><strong>Arthur J. Cutler Memorial ($158.000), äldre travare</strong><br>1.609 meter, autostart.<br><em>Namn (far) – Körsven/tränare</em></p>



<ol class="wp-block-list">
<li>Scottish (e. Kadabra) – Todd McCarthy/John Wengerd</li>



<li>Lexus Kody (e. Archangel) – Andrew McCarty/Ron Burke</li>



<li>Ari Ferrari J (e. Walner) – Brett Beckwith/Tony Alagna</li>



<li>Antognoni (e. Father Patrick) – Yannick Gingras/Ron Burke</li>



<li>Periculum (e. Muscle Hill) – Scott Zeron/Marcus Melander</li>



<li>Hasty Bid (e. My Mvp) – Mark MacDonald/Nancy Takter</li>



<li>Benjamin Hanover (e. Sebastian K.) – Tim Tetrick/Scott Di Domenico</li>



<li>Sir Pinocchio (e. Met’s Hall) – Jasoin Bartlett/Edward Hart</li>



<li>Chapercraz (e. Crazy Wow) – David Miller/Ron Burke</li>



<li>Oh Well (e. Muscle Hill) – Dexter Dunn/Marcus Melander</li>



<li>Get A Wish (e. Wishing Stone) – Åke Svanstedt</li>
</ol>



<p class="wp-block-paragraph"><strong>Svensktränade vinnare i Cutler Memorial</strong><br><em>År – Häst (far) – Tränare</em></p>



<ul class="wp-block-list">
<li>1998 – Kick Tail (e. Sierra Kosmos) – Jan Johnson</li>



<li>2003 – Kadabra (e. Primrose Lane) – Jimmy Takter</li>



<li>2014 – Sebastian K. (e. Korean) – Åke Svanstedt</li>



<li>2016 – Resolve (e. Muscle Hill) – Åke Svanstedt</li>



<li>2017 – Resolve (e. Muscle Hill) – Åke Svanstedt</li>



<li>2019 – Cruzado Dela Noche (e. Muscle Massive) – Marcus Melander</li>



<li>2021 – Manchego (e. Muscle Hill) – Nancy Takter</li>



<li>2022 – Ecurie D (e. Infinitif) – Åke Svanstedt</li>



<li>2023 – Venerate (e. Love You) – Marcus Melander</li>



<li>2024 – Jiggy Jog (e. Walner) – Åke Svanstedt</li>
</ul>



<p class="wp-block-paragraph"><a href="https://racing.ustrotting.com/goto.aspx?target=12,99357" target="_blank" rel="noreferrer noopener">Och här hittar du alla andra svenska hästar som startar på Meadowlands i natt.</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/2024/06/202406151550050i0a0146-617x411.jpg" alt="" class="wp-image-597065"/><figcaption class="wp-element-caption">Daniel Wäjersten och Borups Victory vid Grupp I-segern i  Kymi Grand Prix förra året. Foto: Terhi Piispa-Helisten</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5Finska grupp I-loppet Kymi Grand Prix i Kouvola har sett många namnkunninga vinnare genom åren. Förra året segrade Daniel Wäjerstens  då nybakade Elitloppstvåa <strong>Borups Victory</strong> (e. Googoo Gaagaa). Även svensktränade Elitloppsvinnaren <strong>Brioni</strong> och svenskfödde diton <strong>Commander Crowe</strong> finns i segerlistan.</p>



<p class="wp-block-paragraph">Drygt hälften av upplagorna har vunnits av fransktränade hästar som Elitloppsvinnarna <strong>Timoko</strong> och <strong>Etonnant</strong>, samt Prix dA*Amérique-triumftörerna <strong>Dryade des Bois</strong> och <strong>Jag de Bellouet</strong> för att nämna fyra.</p>



<p class="wp-block-paragraph">I år kan det bli svårt att locka franska travare till loppet med 85.000 euro i förstapris. Det erbjuds nämligen inte flygtransport till Kouvola.<br>Två hästar har hittills bjudit in till årets Kymi GP och båda tränas i Finland: Jukka Hakkarainen-tränade <strong>Massimo Hoist</strong> och dagens deltagare i Prins Daniels lopp, <strong>Crepe Match</strong>, tränad av Harri Koivunen.</p>



<p class="wp-block-paragraph">Kymi GP avgörs den 14 juni.</p>



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



<p class="has-drop-cap wp-block-paragraph">6Vichy (första start kl. 18.20) bjuder på kvällstrav och dit åker Markus B Svedbergs <strong>Dee Godfather</strong> (e. Father Patrick) för att starta i montéloppet Prix de Neuilly Le (€25.000) och i sadeln sitter Eva Bouclet. Distansen är 2.950 meter och förstapriset 11.250 euro. </p>



<p class="wp-block-paragraph">Fyra sadellopp har det blivit för Dee Godfahter på fransk mark och sexåringen kommer närmast från en fjärdeplats för Sofia Adolfsson i Prix des Charmes i Chloet. </p>



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



<p class="has-drop-cap wp-block-paragraph">7Ett stort utbud starthästar finns på kvällens auktion hos Travera, där den digitala katalogen innehåller hela 34 nummer. 23 av dem tillhör kategorin starthästar. <br>En vinstrik dansk med 16 segrar på 59 starter finns bland dessa. Det handlar om <strong>Grumbazz Kini</strong> (e. Great Challenger), som sprungit in 750.241 kronor. En annan fyraåriga stoet <strong>Vikens Tracker</strong> (e. Hard Livin), som vunnit fyra av livets åtta starter.</p>



<p class="wp-block-paragraph">I övrigt säljs åtta fölston, en ettåring (e. Classic Photo) och betäckningsrätt 2025 med Father Patrick och Greenshoe.</p>



<p class="wp-block-paragraph"><a href="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här går det att se hästarna som bjuds ut och följa budgivningen under kvällen.</a></p>

Fokustema
Sju nyheter vid sju
Läs senare
”Han ska bestämma – inte kusken”
Sista chansen att ta en Elitloppsbiljett av egen kraft. Svensk mångmiljonärska slutar. Fyra svenskar i Meadowlands storlopp. Storlopp blir blåst på franska stjärnor? 23 starthästar säljs ikväll.
Dessa och fler bland lördagsmorgonens nyheter.
Dessa och fler bland lördagsmorgonens nyheter.
