
<p class="has-drop-cap">1Öystein Tjomsland är mannen bakom både kallblodens absoluta världsrekord 1.17,7a/1.1640 meter och medeldistansvärldsrekordet 1.19,a1a/2.140 meter. <strong>Brenne Borken</strong> (e. Bork Odin) har det förstnämnda från i somras, medan <strong>Tekno Odin</strong> (e. Moe Odin) satte sitt rekord i Unionskampen på Färjestad för nio år sedan.</p>



<p>Idag på Färjestad (start 14.45) dyker Brenne Borken upp i årets upplaga av Unionskampen. Detta efter att ha galopperat i sitt senaste framträdande på Solvalla i starten efter världsrekordloppet.<br>– Jag var väldigt nöjd med honom efter galoppen. Han blev lite stressad i volten och blev lite för laddad, men fick en bra genomkörare. Mest troligt är det här sista loppet för i år, sade Öystein Tjomsland tlll V65 Direkt.</p>



<p>Tuffaste utmanare kommer från samma stall, Elitkampsvinnaren <strong>Tangen Bork</strong> (e. Bork Odin).<br>– Han gjorde bort sig med galopp i norskt mästerskap och har fått ett litet uppehåll men vann senast på lite tunga ben. Han har haft en lång avelsäsong och kanske är lite mer sliten mentalt av det. Tangen Bork är dock enormt speedig på några hundra meter. Fysiskt är han redo, men metalt vet jag inte, sade Tjomsland.</p>



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



<p class="has-drop-cap">2Unionstravet kördes första gången på Färjestad 24 september 2005 för att fira 100-årsjubileumet av Unionsupplösningen mellan Sverige och Norge 1905. Tävlingsdagen på Färjestad har setts som en match mellan de båda grannländerna och den svenska överlägsenheten har varit stor under de 18 gånger som tävlingsdagen genomförts.</p>



<p>Statistiken i Färjestads banprogram till dagens tävlingar visar att av de 207 lopp som körts har 164 vunnits av hästar tränade av svenskar, medan norska tränare fått nöja sig med 49 segrar. Resterande sex lopp har gått till tränare från andra länder.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/09/20v75.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/2025/03/stensrubinpusolvallaadam-617x333.jpeg" alt="" class="wp-image-699114"/><figcaption class="wp-element-caption">Stens Rubin och Peter Untersteiner vann Bulwarks lopp på Solvalla i februari. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">3Norrmännen lägger allt krut spelmässigt på Unionstravet och därmed väntar lite större V75-pott än vanligt i eftermiddag. Sulkysports tipsexpert Fredrik Persson från Simsalabim lutar sig mot ett singelstreck på stora systemförslaget.<br>Johan Untersteners <strong>Stens Rubin</strong> (e. Readly Express) i gulddivisionen. Så här säger Halmstadtränaren om vinterns häst på svensk travmark.<br>– Spår ett är lite klurigt på Färjestad med korta rakor och kraftig acceleration, men jag har en häst som är väldigt kvick i benen och ska någon klara att ta ledningen är det Stens Rubin. Han känns väldigt fin och är definitivt med i startrusningen, sade Johan Untersteiner till V65 Direkt.</p>



<p><a href="https://sulkysport.se/spelstugan/v75-farjestad-lordag/" target="_blank" rel="noreferrer noopener">––> Här är V75-tipsen med viktiga punkter, drag och avslag på Färjestad.</a></p>



<p>Vill Du spela V75 med Sulkysport?</p>



<p><a href="https://www.atg.se/simsalabim/spel/296591_V75_2025-09-20_15_5" target="_blank" rel="noreferrer noopener">Här finns andelar i systemförslaget för 150 kr/andel.</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/idaodetillardletrot-617x333.jpg" alt="" class="wp-image-764769"/><figcaption class="wp-element-caption">Längst till vänster i bild spurtade Idao de Tillard duktigt till sjätteplatsen i sin första start sedan triumfen i Prix d&#8217;Amérique i januari. Skärmbild Letrot</figcaption></figure>



<p class="has-drop-cap">4På Solvallas superlördag den 11 oktober med Svenskt Travkriterium, Oaks och Grand Prix de l’U.E.T. på menyn finns även finalen i UET Elie Circuit för de äldre stjärnorna med 2,8 miljoner kronor till vinnaren. Sista chansen att kvala in dit sker idag i belgiska Mons, där bland annat dubble Prix d’Amérique-vinnaren Idao de Tillard (e. Severino) dyker upp.</p>



<p><strong>Grand Prix de Wallonie</strong> (€150.000)<br>Äldre hästar. 2.840 meter, autostart.<br><em>Namn (far) – Körsven</em></p>



<ol class="wp-block-list">
<li><strong>Josh Power </strong>(e. Offshore Dream) – Sébastien Ernault</li>



<li><strong>Inexess Bleu </strong>(e. Vittel de Brevol – Alexandre Abrivard</li>



<li><strong>Banderas Bi </strong>(e. Ganymede) – Théo Duvaldestin</li>



<li><strong>Cicero Noa</strong> (e. Mandarino Blue) – Christophe Martens</li>



<li><strong>Elvis Du Vallon </strong>(e. Reve de Beylev) – Piet van Pollaert</li>



<li><strong>Idao De Tillard </strong>(e. Severino) – Clément Duvaldestin</li>



<li><strong>Inmarosa </strong>(e. Amiral Sascha) – Léo Abrivard</li>



<li><strong>Iguski Sautonne</strong> (e. Village Mystic) – Matthieu Abrivard</li>



<li><strong>Happy Danica</strong> (e. Briac Dark) – Alexis Garandeau</li>



<li><strong>Instrumentaliste</strong> (e. Ready Cash) – Michael Nimczyk</li>



<li><strong>Staro Mack Crowe</strong> (e. Bold Eagle) – Magnus A Djuse</li>



<li><strong>Justin Bold </strong>(e. Bold Eagle) – Pierre-Yves Verva</li>



<li><strong>Cyriel d’Atom</strong> (e. Otello Pierji) – Hanna Huygens</li>



<li><strong>Hulysse Digeo</strong> (e. Reve de Beylev) – Jean-William Hallais</li>
</ol>



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



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2025/09/apexsep12.jpg" alt="" class="wp-image-767194"/><figcaption class="wp-element-caption">Utvändige Apex och Dexter Dunn besegrar Åke Svanstedt och Magic Punk. Foto: Dean Gillette</figcaption></figure>



<p class="has-drop-cap">5För 100.000 kanadensiska dollar har nio hästägare kunnat köpa plats i världens högst doterade tvååringslopp Mohawk Million ($1.000.000), utan att behöva bestämma vilken häst som ska tävla förrän vid anmälan till loppet. Lottköparna kan till och med överlåta sin plats till en annan hästägares tvååring.</p>



<p>Inatt är det dags för den sjätte upplagan av loppet där nio ägare köpt in sig i loppet. Den tionde platsen till vinnaren av William Wellwood Memorial (C$610.000), nämligen <strong>Ardonne</strong> (e. Tactical Landing).</p>



<p>Av fem upplagor av loppet har Marcus Melander vuniit två, med <strong>Oh Well</strong> (e. Muscle Hill)  2022 och <strong>Maryland</strong> (e. Chapter Seven) ifjol. Marcus har ett starkt kort till start även i årets upplaga. Det handlar om Peter Haughton Memorial-vinnaren <strong>Apex</strong> (e. 368.950). Åke Svanstedt mönstrar <strong>Dublin Hanover</strong> (e. Captain Corey), vilken vunnit försök och final i Pennsylvania Sire Stakes ($300.000).</p>



<p>Treåringarna tävlar också om stora pengar på Mohawk och i Canadian Trotting Classic (C$615.000) jagar just fjolårets tvååringskung <strong>Maryland</strong> årets första seger. På sex starter har det hittills blivit fyra andraplatser och tredjeplatsen i Hambletonian Stakes.<br>Maryland gick ett kvallopp på Red Mile i Lexington i söndags och noterade 1.09,2/1.609 meter efter vassa 1.05,1 sista quartern för Dexter Dunn.</p>



<p><strong>Mohawk Million (C$1.000.000)</strong><br>Tvååringar, 1.609 meter autostart.<br><em>Namn (far) – Körsven/tränare</em></p>



<ol class="wp-block-list">
<li><strong>Apex</strong> (e. Walner) – Dexter Dunn/Marcus Melander</li>



<li><strong>Silverstein</strong> (e. Chapter Seven) – David Miller/Matthew Burkholder</li>



<li><strong>Ardonne</strong> (e. Tactical Landing) – Scott Zeron/Megan Scran</li>



<li><strong>Shimmering Hanover</strong> (e. Captain Corey) – Louis-Philippe Roy/Luc Blais</li>



<li><strong>Cambridge Hanover</strong> (e. Walner) – Jason Bartlett/Andrew Harris</li>



<li><strong>Endurance</strong> (e. Captain Corey) – Andrew McCarthy/Christopher Beaver</li>



<li><strong>Dublin Hanover</strong> (e. Captain Corey) – Åke Svanstedt</li>



<li><strong>Strobe Lite</strong> (e. Alarm Detector) – James MacDonald/Benoit Baillargeon</li>



<li><strong>Diabolic Hill</strong> (e. Muscle Hill) – Todd McCarthy/Annie Stoebe</li>



<li><strong>Ai</strong> (e. Chapter Seven) – Yannick Gingras/Ron Burke</li>
</ol>



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



<p class="has-drop-cap">6Tre italienska topphästar har en fribiljett inni landets Derby som avgörs den 20 oktober. Grupp I-vinnare i pastalandet är nämligen garanterade finalplats och behöver inte mäta krafterna med sina konkurrenter i kvalen som körs idag.</p>



<p>Det handlar om Philippe Allaires <strong>Ginostrabliggi </strong>(e. Muscle Hill), 1.11,1am/€327.739, Alessandro Gocciadoros <strong>Golden Gio </strong>(e. Face Time Bourbon), 1.13,1m*/€135.321, och <strong>Guglielmo Jet </strong>(e. Maharajah), 1.12,4ak/€149.758, som alla är direktkvalificerade till finalen den 20 oktober.</p>



<p>De italienska treåringarna gör upp i tre försök, där det gäller att vara bland de tre främsta och dessutom går de två treåringarna med de snabbaste tiderna vidare. Det betyder att finalfältet innehåller 14 hästar.</p>



<p><a href="https://sulkysport.se/stjarnor-saknas-i-derbykval/" target="_blank" rel="noreferrer noopener">Här är startlistorna till de italienska Derbykvalen.</a></p>



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



<p class="has-drop-cap">7Igår vann <strong>Kaley D.C.</strong> (e. Wishing Stone) Derbyrevanschen för ston i danska Aalborg. I eftermiddag är det dags för hingstarna att göra upp i Ålborgs Stora Pris med 125.000 danska kronor till vinnaren.</p>



<p>Joakim Lövgrens Derbyvinnare <strong>Kreadlys Lew</strong> (e. Readly Express) står över loppet och laddas för Europaderbyt, och lämnar därmed fältet öppet för konkurrenterna i Ålborg.</p>



<p><strong>Ålborgs Stora Pris</strong><br>Fyraåringar, 2.140 meter autostart.<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li><strong>Kazio</strong> (e. Muscle Massive) – Birger Jörgensen (Henrik Thomsen)</li>



<li><strong>Karat C.N.</strong> (e. Express Bourbon) – Michael Lönborg</li>



<li><strong>Klinton</strong> (e. Varenne) – Jeppe Juel</li>



<li><strong>Forest Jet</strong> (e. Wishing Stone) – Rene Kjaer (Jan Friis)</li>



<li><strong>Keystone</strong> (e. Wishing Stone) – Mads Henriksen (Nicklas Korfitsen)</li>



<li><strong>Kungfufighting</strong> (e. Nuncio) – Jan Dahlgaard (Peter Rudbeck)</li>



<li><strong>Kanon Laser</strong> (e. One Too Many) – Steen Juul</li>



<li><strong>Kalles Krisbe Notz</strong> (e. executive Caviar) – Morten Friis (Christina Beck)</li>



<li><strong>Kesse Tårs</strong> (e. Donato Hanover) – Knud Mönster</li>



<li><strong>Karlo Molar</strong> (e. Googoo Gaagaa) – Flemming Jensen</li>



<li><strong>Kombardo Skov</strong> (e. Dominion Beach) – Henrik Lönborg</li>
</ol>
