
<p class="has-drop-cap wp-block-paragraph">1När Kronprinsessan Victoria och Daniel Westling skulle gifta sig en lördagseftermiddag den 19 juni 2010 var goda råd dyra. Hur skulle en sådan krock påverka Bodentravets viktigaste tävlingsdag på året? Lösningen blev början på vad som blivit en tradition i mitten av juni varje år med midnattstrav och V75 på kvällen.<br>Ikväll (första start 18.30) är det dags för årets travfest under midnattssolen med Grupp I-loppet Norrbottens Stora Pris som höjdpunkt med en miljon kronor till vinnaren.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/07/donfanuccizetheat-617x333.jpg" alt="" class="wp-image-332835"/><figcaption class="wp-element-caption">Daniel Redéns Don Fanucci Zet och Örjan Kihlström. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Jörgen Westholm har tränat en vinnare i Norrbottens Stora Pris – <strong>Antonio Tabac</strong> (e. Crazed) pandemisommaren 2020 – och har dubbla chanser i året upplaga genom fjolårstvåan <strong>Castor The Star</strong> (e. Maharajah) och Frankrikeexperten <strong>Working Class Hero</strong> (e. Village Mystic), där <strong>Don Fanucci Zet</strong> (e. Hard Livin) är i favoritposition trots spår åtta bakom bilen.</p>



<p class="wp-block-paragraph">Sulkysports tipsexpert tror på seger för Elitloppstvåan – och för Westholm med <strong>Automatic Flight</strong> (e. Nuncio) i klass III, trots att hästen är segerlös i sex starter i år och bara vunnit en av tio starter i livet.<br>Han får medhåll i segerkänslan av fyraåringens kusk Mats E Djuse.<br>– Han var ute mot tuffa hästar på Solvalla på Elitloppsfredagen och fick gå en stor del av loppet utan rygg. Gör han om den prestationen bör det räcka väldigt långt. Det kan bli strul från det här läget, men jag hoppas att det stämmer lite grand. Då startar han med bra segerchans, sade Mats E Djuse till V65 Direkt.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v75-tips-tva-spikar-galler-pa-midnattstravet/" target="_blank" rel="noreferrer noopener">––> Här är stora tipsgenomgången med analyser, spikar, drag och systemförslag till V75.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">2Innan midnattstravet drar igång ska två andra svenska tävlingar avverkas. Det början med breddlopp på Jägersro (start 11.10), innan Vaggeryd (start 14.00) tar vid med den roliga kusk- och ryttarmatchen Dubbelkampen.</p>



<p class="wp-block-paragraph">Tolv kuskar/ryttare gör upp i två lopp, en i sulky och ett i sadeln, för att kora den mest allsidige i de båda disciplinerna. Tyvärr blev Hilda Eskilsson utan ritt i montéavdelningen och kör enbart sulkyloppet.</p>



<p class="wp-block-paragraph">Jönköping-Vaggeryds Travsällskap har instiftat ett vandringspris för Dubbelkampen. Den som får tre inteckningar i priset får behålla det. Tova Bengtsson tog hem det första efter att ha vunnit tre av de fyra första upplagorna. Tova har dessutom redan en inteckning i det nya vandringspriset tillsammans med Henriette Larsen, Jennifer Persson och fjolårsvinnaren Jonathan Carre.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/06/250614.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens tävlingar.</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/04/borupsvictoryelinapaavola-617x333.jpg" alt="" class="wp-image-708682"/><figcaption class="wp-element-caption">Borups Victory och Daniel Wäjersten vinner före Massimo Hoist i Seinäjoki Race. Foto Elina Paavola</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3<strong>Borups Victory</strong> (e. Googoo Gaagaa) och hans tränare Daniel Wäjersten är något av Finlandspecialister. Förra året bjud på två Grupp I-segrar – Seinäjoki Race och Kymi Grand Prix. I våras bockade Borups Vicotry och Wäjersten av Seinäjoki Race och i eftermiddag är det dags för Kouvolas storlopp.<br>Fjolårets Elitloppstvåa Borups Victory var en av huvudkandidaterna till segern i årets upplaga på Solvalla, men fick nöja sig med femteplatsen på 1.09,4a/1.609 meter.</p>



<p class="wp-block-paragraph">Knappt slagen om den placeringen och på samma tid som Borups Victory gav <strong>Massimo Hoist</strong> (e. Muscle Hill) finsk travsport en skön framgång i Solvallas sprinterlopp. De båda hästarna möts igen i Kymi GP, där Wäjersten vann spårlottningen med spår tre, medan Massimo Hoist finns direkt på utsidan tillsammans med Hannu Torvinen.</p>



<p class="wp-block-paragraph">Den finske toppkusken har dock inte givit slaget förlorat på förhand.<br>– I de senaste starterna har det inte funnits någon anledning att visa startsnabbheten, men den finns också om det behövs. Borups Victory blir en svår motståndare om han kommer till ledningen, men vi ska försöka utmana. Känslan är god och förväntningarna är höga, säger Hannu Torvinen till <a href="https://www.maaseuduntulevaisuus.fi/hevoset/112c0636-884b-4602-8824-104ff062297e" target="_blank" rel="noreferrer noopener">Ravinetti</a>.</p>



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



<p class="has-drop-cap wp-block-paragraph">4Kymi Grand Prix har körts sedan 1998 och har många fina märken i segerlistan. Första upplagan vanns exempelvis av Prix d’Amérique-vinnaren <strong>Dryade des Bois</strong> (e. Off Gy) och Jos Verbeeck. Bland vinnare i övrigt finns Elitloppsvinnarna <strong>L’Amiral Mauzun</strong> (e. Bon Conseil), <strong>Commander Crowe</strong> (e. Juliano Star), <strong>Brioni</strong> (e. Timberland), <strong>Timoko</strong> (e. Imoko) och <strong>Etonnant</strong> (e. Timoko). Commander Crowe har dessutom vunnit Kymi GP två gånger.</p>



<p class="wp-block-paragraph">När det gäller svenskfödda vinnare har det – förutom Commander Crowe – blivit faktiskt bara blivit ytterligare tre triumfer. Detta genom <strong>Camilla Highness</strong> (e. Super Arnie), <strong>Racing Mange</strong> (e. Orlando Vici) och titelförsvararen <strong>Borups Victory</strong>.</p>



<p class="wp-block-paragraph"><strong>Startlista Kymi Grand Prix (€170.000)</strong><br>2.100 meter autostart:<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Crepe Match (e. Creatine) – Olli Koivunen (Harri Koivunen)</li>



<li>Holcombe Zet (e. Daley Lovin) – Rikard N Skoglund (Daniel Redén)</li>



<li>Borups Victory (e. Googoo Gaagaa) – Daniel Wäjersten</li>



<li>Massimo Hoist (e. Muscle Hill) – Hannu Torvinen (Jukka Hakkarainen)</li>



<li>Banderas Bi (e. Ganymede) – Alessandro Gocciadoro</li>



<li>Diva Ek – struken</li>



<li>Decision Maker (e. Nuncio) – Magnus A Djuse (Stefan Melander)</li>



<li>Ideal San Leandro (e. Timoko) – Björn Goop</li>



<li>Goeland d’Haufor (e. Voltigeur de Myrt) – Ari Moilanen (Markku Nieminen)</li>



<li>Lightning Stride (e. Twister Bi) – Santtu Raitala (Katja Melkko)</li>
</ol>



<p class="wp-block-paragraph">Vid sidan om storloppet syns svensktränade travare i några av ramloppen. Daniel Redén tar ut<strong> Fly By</strong> (e. Chapter Seven) i ett fyraåringslopp och möter Alessandro Gocciadoros <strong>Fly Top</strong> (e. Tesoro Degli Dei). Redén mot Gocciadoro blir det även i femåringsloppet genom <strong>Herakles Zet</strong> (e. Propulsion) och <strong>Ete Jet</strong> (e. Maharajah). Gocciadoro startar även <strong>Eloida</strong> (e. Napoleon Bar) i ett stolopp.</p>



<p class="wp-block-paragraph"><a href="https://heppa.hippos.fi/heppa/app?ct=YXBwbGljYXRpb24vcGRm&#038;d=dHJ1ZQ%3D%3D&#038;dr=&#038;f=b2hqZWxtYXRpZWRvdC5LXzE0LjA2LjIwMjUucGRm&#038;m=P47YGBeqJfKV6QLA%2BKGJX%2FAzFBw%3D&#038;service=pdftmp" target="_blank" rel="noreferrer noopener">Här är startlistorna till Kouvolas tävlingar idag.</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/06/02dialsquaresrc1x-617x412.jpg" alt="" class="wp-image-728282"/><figcaption class="wp-element-caption">Två starter och lika många segrar har det blivit för Dial Square och Åke Svanstedt tillsammans. Foto: New Image Media</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5Mohawk Raceway står i centrum i nordamerikansk travsport i natt med finaler i Armbro Flight Stakes (C$210.000) och Goodtimes Stake (C$227.000). </p>



<p class="wp-block-paragraph">Tre svenskfödda travare har kvalat in till finalen i Armbro Flight Stakes för äldre ston och det handlar om Åke Svantedts <strong>Dial Square</strong> (e. Ready Cash) och Per Engbloms duo <strong>Golden Rain</strong> (e. Bold Eagle) och <strong>Bravo Angel</strong> (e. Readly Express). <br>Dial Square vann sitt försök och är obesegrad i två starter i regi Åke Svanstedt där hon har vunnit på 1.09,1 och 1.09,4. </p>



<p class="wp-block-paragraph">Åke Svanstedt har också en svenskfödd travare i finalen i Goodtimes Stake för treåriga hingstar och valacker. Det handlar om <strong>Gap Kronos</strong> (e. Face Time Bourbon). </p>



<p class="wp-block-paragraph"><strong>Startlista Armbro Flight Stakes (C$210.000)</strong><br>Treåriga &#038; äldre ston, 1.609 meter autostart:<br><em>Namn (far) – Kusk/tränare</em></p>



<ol class="wp-block-list">
<li>M-M’s Dream (e. Swan For All) – Yannick Gingras/Ron Burke</li>



<li>Golden Rain (e. Bold Eagle) – Doug McNair/Per Engblom</li>



<li>Bravo Angel (e. Readly Express) – Bob McClure/Per Engblom</li>



<li>Call Me Goo (e. Googoo Gaagaa) – Åke Svanstedt</li>



<li>Dial Square (e. Ready Cash) – James MacDonald/Åke Svanstedt</li>



<li>Willy’s Home Run (e. Archangel) – Tim Tetrick/Robert Kyle Fellows</li>



<li>Emoji Hanover (e. Greenshoe) – Tyler Jones/Luc Blais</li>



<li>Drawnimpression (e. Muscle Hill) – Louis-Philippe Roy/Luc Blais</li>



<li>Nelson Brite Eagle (e. Bold Eagle) – Dexter Dunn/Åke Svanstedt</li>



<li>Chake (e. Donato Hanover) – Jason Bartlett/Per Engblom</li>
</ol>



<p class="wp-block-paragraph"><strong>Startlista Goodtimes Stake (C$227.000)</strong><br>Treåriga hingstar/valacker. 1.609 meter autostart:<br><em>Namn (far) – Kusk/tränare</em></p>



<ol class="wp-block-list">
<li>Fadeway Hanover (e. Chapter Seven) – Travis Cullen/Benoit Baillargeon</li>



<li>Gap Kronos (e. Face Time Bourbon) – Åke Svanstedt</li>



<li>Galen Erso (e. Green Manalishi) – Doug McNair/R Gregg McNair</li>



<li>Emoticon Legacy (e. Walner) – Louis-Philippe Roy/Luc Blais</li>



<li>Lmc Wagon Wheel (e. Wheeling N Dealin) – Tyler Borth/Benoit Baillargeon</li>



<li>Landing On Time (e. Tactical Landing) – James MacDonald/Rick Zeron</li>



<li>Wildturkey Hanover (e. Bar Hopping) – Philippe Hudon/Ron Waples Jr.</li>



<li>Eugene the Genius (e. Helpisontheway) – Yannick Gingras/Melissa Essig</li>



<li>Blank (e. Gimpanzee) – Dexter Dunn/Marcus Melander</li>
</ol>



<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/unknown-7-617x411.jpeg" alt="" class="wp-image-725873"/><figcaption class="wp-element-caption">Paul-Philippe Ploquin vinner med svenskfödde Unico Broiline. Foto: Scoopdyga</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6Idag inleds sommarsäsongen på Parisbanan Enghien (första start 13.23) där 19 tävlingsdagar ska avverkas fram tills den 14 augusti fördelat på tre i juni, tio i juli och sju i augusti.</p>



<p class="wp-block-paragraph">Det är gott om blågula intressen vid sommarpremiären och fyra svenskfödda travare hittas i dagens största lopp Prix de New York (€90.000) över 2.150 meter med autostart. <br>Bästa utgångsläget drog <strong>Unico Broline</strong> (e. Cantab Hall) med bricka fem. Hästen slog till med seger direkt i debuten för nye tränaren Thierry Duvaldestin i spurtade hem Prix Pythia (€75.000) för två veckor sedan. Bakspår väntar däremot för fransktränade duon <strong>Elegance Kronos</strong> (e. Muscle Hill) och <strong>Self Explosive</strong> (e. Explosive Matter), samt Sabine Kagebrants <strong>Iznogoud Am</strong> (e. Muscle Hill).</p>



<p class="wp-block-paragraph">I Prix de Blamont (€46.000) är alla hästar utom en födda utanför Frankrikes gränser. Fem av dem är svenskfödda: <strong>Jolicoeur</strong> (e. Atlas de Joudes), Fredrik B Larssons <strong>Robthebank</strong> (e. The Bank), Conrad Lugauers <strong>Declan</strong> (e. From Above), Christoffer Erikssons <strong>Global Duty</strong> (e. Trixton) och <strong>Mister Jupiter</strong> (e. Ready Cash). Dessutom har Robert Bergh sänt ned danskfödde unghästtoppen <strong>Harpy</strong> (e. Bar Hopping).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/enghien-2025-06-14/" target="_blank" rel="noreferrer noopener">Här är startlistorna till Enghiens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">7Starthästarna dominerar åter när det ikväll är dags för internetauktion hos Travera. Av 26 hästar i den digitala katalogen kommer 21 från den kategorin.<br>Toppstoet <strong>Filippa B.J. </strong>(e. Muscle Mass) – för dagen skadad – är det största namnet. Stoet har sprungit in nästan 1,9 miljoner kronor efetr 13 vinster på 49 starter.</p>



<p class="wp-block-paragraph">På väg mot sin första miljon insprunget är femårige <strong>Cherokee Face</strong> (e. Bold Eagle), som ståtar med 925.250 kronor i startprissumma och startade så sent som igår med en tredjeplats på 1.12,0a/2.140 meter som resultat. Ifjol avslutade han säsongen med att sluta femma i Breeders Crown-finalen för fyraåriga hingstar/valacker.</p>



<p class="wp-block-paragraph">På unghästsidan finns ett ettårigt sto (e. Donato Hanover) och ett tvåårigt dito (e. Cash Gamble). Dessutom säljs tre fölston.</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
Svenskarna i grupp I-jakten
Bröllop bakom midnattstravet. Läge att hålla Westholm och Djuse i handen? Finlandsexperten Borups Vixtory mot ny Grupp I-seger. Svanstedt på storloppsjakt i Kanada. BC-femma säljs ikväll.
Detta och mer bland nyheterna denna lördagsmorgon.
Detta och mer bland nyheterna denna lördagsmorgon.
