
<p class="has-drop-cap">1 Scioto Downs i Ohios huvudstad Columbus står som värd för årets Breeders Crown-finaler i Nordamerika och på något sätt känns det rimligt att loppen för de bästa två- och treåringarna hamnat på just Scioto Downs. </p>



<p>Ohio är travsportens centrum i USA ur flera aspekter, bland annat för att The United States Trotting Association, sportens högsta beslutande organ, funnits i Columbus sedan 1948 och hästtraditionen är stark i ”The Buckeye State”.</p>



<p>Kvällens tävlingar är vikta åt de yngsta deltagarna och två divisioner för tvååriga travare körs på Scioto Downs under tävlingsdagen. Svenskt deltagande finns i massor. Vill ”jänkarna” ha hemmaseger får de lita till Ron Burke, Vernon Beachy, Todd Luther, Jim Campbell och Luc Blais, för det är stor dominans av den svensktränade armadan.</p>



<h2 class="wp-block-heading">Breeders Crown ($700.000)</h2>



<p>Tvååriga ston.<br>1.609 meter, autostart.<br>Namn (far) – Tränare</p>



<ol class="wp-block-list">
<li>Nevis Peak (e. Walner) – Ron Burke</li>



<li>Birr Castle (e. Captain Corey) – Marcus Melander</li>



<li>Blue Ranger (e. In Range) – Marcus Melander</li>



<li>Two Day Hangover (e. Captain Corey) – Marcus Melander</li>



<li>She’s A Home Run (e. Captain Corey) – Vernon Beacy</li>



<li>Climatic Hanover (e. Walner) – Lucas Wallin</li>



<li>Putitondad’stab (e. Walner) – Lucas Wallin</li>



<li>Dandelion Wine (e. Ecurie D.) – Åke Svanstedt</li>



<li>Kissme Ifyoucan (e. In Range) – Todd Luther</li>
</ol>



<h2 class="wp-block-heading">Breeders Crown ($700.000)</h2>



<p>Tvååriga hingstar/valacker<br>1.609 meter, autostart.<br>Namn (far) – Tränare</p>



<ol class="wp-block-list">
<li>Yankee Boss (e. Captain Corey) – Åke Svanstedt</li>



<li>Whateverittakes Ås (e. Walner) – Anette Lorentzon</li>



<li>Jimdougie Armitage (e. Captain Corey) – Åke Svanstedt</li>



<li>Carbon Fiber (e. Gimpanzee) – Ron Burke</li>



<li>Lifetime Dreamer (e. Ecurie D.) – Åke Svanstedt</li>



<li>Wrong Sounds Right (e. Tactical Landing) – Jim Campbell</li>



<li>Access Now (e. Walner) – Luc Blais</li>



<li>Presidente (e. Walner) – Nancy Takter</li>



<li>Top Reacher (e. Muscle Hill) – Marcus Melander</li>
</ol>



<p><a href="https://racing.ustrotting.com/card.aspx" target="_blank" rel="noreferrer noopener">Startlistorna till Scioto Downs finns här.</a></p>



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



<p class="has-drop-cap">2 Flera av de bästa franska treåringarna kliver ut på Vincennes bana ikväll och det handlar om två grupp II-lopp med 120.000 euro i samlad prispott. </p>



<p>Åtta hingstar provar lyckan i Prix Victor Regis (€120.000) och mest meriterad i gänget är Philippe Allaires <strong>Nat King Cole</strong> (e. Ready Cash), som kommer att tillhöra favoriterna i loppet.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/08/vauloge3-617x365.jpg" alt="" class="wp-image-891867"/><figcaption class="wp-element-caption">Nat King Cole och David Thomain. Foto: Gerard Forni</figcaption></figure>



<p><strong>Nuevo Cash</strong> (e. Ready Cash) tillhörde kullens bästa hästar under fjolårssäsongen, men i år har det krånglat, fram till förra starten då tränaren Thierry Duvaldestin valde att prova hästen i monté. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/02/comtedemontesson1-617x339.jpg" alt="" class="wp-image-819657"/><figcaption class="wp-element-caption">Nocive du Choquel vinner för Francois Lagadeuc. Foto: Gerard Forni</figcaption></figure>



<p>Prix Uranie (€120.000) för treåriga ston har lockat <strong>Nocive du Choquel</strong> (e. Face Time Bourbon), <strong>Normandie Niemen</strong> (e. Italiano Vero) och <strong>Naya d’Eronville</strong> (e. Hohneck) till start och på papperet är stonas drabbning ett minst sagt spännande lopp på förhand.</p>



<p>Båda loppen körs över 2.175 meter på Vincennes stora bana.</p>



<p><a href="https://www.letrot.com/courses/programme/2026-10-23/7500" target="_blank" rel="noreferrer noopener">Startlistor till Vincennes tävlingar hittar du här.</a></p>



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



<p class="has-drop-cap">3 <strong>Jennifer Tillman</strong> är den enda kvinnan som vunnit Elitloppsförsök. 2015 slog hon till med Per  Eriksson-tränade <strong>Royal Fighter</strong> (e. Varenne) 2015, men 2020 lämnade hon in körlicensen efter 455 segrar i karriären.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/11/royalfightermal2-617x333.jpg" alt="" class="wp-image-34451"/><figcaption class="wp-element-caption">Royal Fighter och Jennifer Tillman vid segern i Elitloppsförsöket 2015. Foto: Micke Gustafsson/ALN</figcaption></figure>



<p>Sedan 2015 har forna hemmabanan Bollnäs lyft fram hennes prestationer genom damloppet Jennifer Tillman Invitation och ikväll i <strong>Bollnäs</strong> (första start 18.20) är det dags för årets upplaga. Elva tjejer slåss om segern och ett hederspris i form av Jennifer Tillmans travsmycke i ett lopp med 50.000 kronor i förstapris.</p>



<p><strong>Tidigare vinnarna av utmaningen: </strong>Kajsa Frick (2015), Susanne H Osterling (2016), Jenni H Åsberg (2017), Emilia Leo (2018 och 2024), Kim Moberg (2019), Helena Ehn (2020), Linda Sedström (2021), Jennifer Persson (2022 och 2023) samt Madelen Berås (2025).</p>



<p>Tre av tjejerna i årets upplaga har vunnit Tillmans Invitation tidigare, däribland Madelen Berås som tog hem fjolårets damlopp. Nu har hon chansen till andra raka när hon kör Peter G Norman-tränade <strong>Grasshopper R.L.</strong> (e. Fourth Dimension).</p>



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



<p class="has-drop-cap">4 Bollnäs är kvällens huvudbana och norskfödde femåringen <strong>Iaintnoquitter</strong> (e. Quite Easy) har gjort allt rätt i Jörgen Westholms regi. Tre starter har slutat med lika många segrar. Två av dem togs i försök i bronsdivisionen, den tredje i finalen på Solvalla på Kriteriedagen. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/10/11iaintnoquitter-617x333.jpg" alt="" class="wp-image-908212"/><figcaption class="wp-element-caption">Mats E Djuse hade full koll på Jörgen Westholm-tränade Iaintnoquitter. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Priskontot har nästan fördubblats under månaderna hos Westholm och trippeln belönades med 540.000 kronor. Den långsiktiga planen är att tävla i Frankrike, men tränare Westholm säger att hästen inte har något ”perfekt” program i vinter.</p>



<p>På vägen mot nya mål väntar start ikväll i ett vanligt lopp stängt vid 1,5 miljoner och Iaintnoquitter är anmäld med skor. Han har tävlat barfota runt om vid alla tre segrar i Westholm-regi. Större uppgifter i sikte efter denna?</p>



<p>Kvällen kompletteras med breddlopp i <strong>Kalmar</strong> (första start 18.30).</p>



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



<p class="has-drop-cap">5 Flera spännande ston dyker upp i ett treåringslopp på lunchbanan <strong>Halmstad</strong> (första start 12.20). Hemmatränaren Johan Untersteiner har en duo och <strong>Virgin Tile</strong> (e. Tactical Landing) har imponerat i två raka segrar. Senast avgjorde hon snyggt från dödens på 1.14,5am utan att Untersteiner behövde begära något.</p>



<p>Nu väntar livets tredje start när Virgin Tile inleder från spår två bakom bilen i spårtrappan.</p>



<p>Desto mer rutin har några av de tuffaste motståndarna. Christoffer Erikssons tyska <strong>Swept Away S.</strong> (e. Bar Hopping har hunnit med 14 starter och vunnit på en 1.12-tid. Joakim Lövgrens <strong>Radja Invicta</strong> (e. Maharajah) nästan lika många med 13 framträdanden och starka 1.13,0am som tvåa förra veckan, medan Maria Törnqvist-tränade <strong>Mireya Wibb</strong> (e. Maharajah) inlett med två vinster på sex starter. Senaste vinsten togs på 1.14,5 över medeldistans med voltstart.</p>



<p>Lunchens V65-kupong kompletteras med fem lopp från en delningsproposition över sprinterdistans för hästar med högst 800.000 kronor – och 1.500 startpoäng. Dit anmäldes 80 hästar och 60 av dem får chansen att tävla.</p>



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



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



<p class="has-drop-cap">6 Spännande svenska bidrag finns med på både Vincennes och i Strasbourg denna fredag. Maria Törnqvist låter fyraåriga stoet <strong>Slipstream Zon</strong> (e. Googoo Gaagaa) debutera på fransk mark i Prix Bellona (€46.000) för fyraåringar på Vincennes. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/09/6slipstreamzon-617x333.jpg" alt="" class="wp-image-773057"/><figcaption class="wp-element-caption">Slipstream Zon och Carl Johan Jepson vinner på Solvalla. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Mathieu Mottier sitter upp bakom stoet som närmast kommer från en femteplats i Derbystoet på Jägersro och som tjänat knappa miljonen kronor under karriären. Slipstream Zon börjar från spår fem bakom bilen.</p>



<p>Debut på fransk mark gör även Christoffer Erikssons <strong>Orosei Boko</strong> (e. Readly Express), detta i Prix Zosma (€53.000) över 2.100 meter på Vincennes. Eric Raffin har anlitats som kusk bakom Erikssons femåring och man börjar från spår nio bakom bilen.</p>



<p>I Strasbourg jagar Erik Lindegrens <strong>Ruger</strong> (e. Readly Express) ytterligare en seger i Frankrike. Sjätte årssegern i Frankrike kan det bli tal om när Florian Desmigneux sitter upp bakom Gävlehästen i Prix Jamin (€32.000) och duon startar med 25 meters tillägg över grunddistansen 2.800 meter. </p>



<p>Segervan i Frankrike är även Jörgen Westholms femåring <strong>Large Level</strong> (e. Face Time Bourbon) och Gabriele Gelormini åker till Strasbourg för att köra hästen i Prix de Grosbois (€22.000) över 2.800 meter.</p>



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



<p class="has-drop-cap">7 Vi avslutar där vi började, i USA, för det är inte bara i Ohio det tävlas denna fredag. Kuskeliten är förstås på plats på Scioto Downs, men Meadowlands tävlar och tre divisioner i Kindergarten Series ($25.000) för tvååringar ska avverkas under kvällen.</p>



<p>Åke Svanstedt har ett knippe hästar till start i tvååringsloppen och först ut är <strong>Joseph the Great</strong> (e. Walner) och <strong>Wyoming</strong> (e. Walner), vilka kommer att få möta Marcus Melander <strong>Obiter Dictum</strong> (e. Tactical Landing) som för ett par veckor sedan vann på 1.09,6a/1.609 meter på The Red Mile i Lexington.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/10/obiterdictumddm261008adamstromstalltzedited.jpg" alt="" class="wp-image-914284"/><figcaption class="wp-element-caption">Obiter Dictum och Dexter Dunn. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Jimmy Takter svingar sig upp i tävlingssulkyn bakom dottern Nancys <strong>City of Light</strong> (e. Chapter Seven) I Kindergarten Series för tvååriga ston och kommer att få möta tuffa konkurrenter i bland andra stallkamraten <strong>Rio de Janeiro</strong> (e. Walner) och Åke Svanstedts <strong>Orinoco</strong> (e. Captain Corey).</p>



<p>Jimmy får chansen bakom Nancy Takters <strong>Barolo</strong> (e. Alrajah One) i sista loppet i Kindergarten Series, där Daniel Redéns och Marcus Melanders <strong>Gustav Vasa</strong> (e. Face Time Bourbon) jagar andra segern för året. Svanstedt-stallet mönstrar<strong> Lincoln Kronos</strong> (e. Walner) och <strong>Bentley Blue Chip</strong> (e. Walner), medan Lucas Wallin plockar ut <strong>Whatachapter Ss S</strong> (e. Fourth Dimension) i samma lopp.</p>



<p><a href="https://racing.ustrotting.com/card.aspx" target="_blank" rel="noreferrer noopener">Startlistor till Meadowlands tävlingar hittar du här.</a></p>



<p></p>

Fokustema
Sju nyheter vid sju
Läs senare
Svenskhoppen i kväll
Det är tid för amerikanska Breeders Crown och det är i Ohio årets finaler avgörs. Svensktränat dominerar stort.
Treåringstoppar på Vincennes. Svenskar i farten i Frankrike.
Tillman bjuder in i Bollnäs. Finalvinnare tillbaka på samma bana.
Här är fredagens Sju nyheter vid sju.
Här är fredagens Sju nyheter vid sju.
