
<p class="has-drop-cap wp-block-paragraph">1Stig H Johansson är Sveriges segerrikaste trönare med 8.206 segrar under sin sagolika karriär- Stig H är en av 62 tränare som nått tusenklubben som segrare med svensk licens.</p>



<p class="wp-block-paragraph">Vem är näst på tur i det extremt celebra sällskapet? Bollnästränaren Thomas Lönn har knackat på dörren ett bra tag, men fortfarande fattas 18 segrar till milstolpen. 982 segrar står nämligen 63-åringen noterad för och i eftermiddag reser han till Boden (första start 13.30) för att knipa en pinne till.</p>



<p class="wp-block-paragraph"><strong>Prince A&#8217;lir</strong> (e. Maharajah) är den stora förhandsfavoriten i klass III-försöket över lång distans.<br>– Han trampar i väg rejält från början och förhoppningen är väl att vi ska komma till ledningen och stanna där länge, helst hela vägen. Vi åker upp till Boden och är optimister, säger Thomas Lönn till Kanal75.</p>



<p class="wp-block-paragraph"><strong>Sveriges segerrikaste tränare:</strong></p>



<ol class="wp-block-list">
<li>Stig H Johansson – 8.206</li>



<li>Olle Goop – 7.696</li>



<li>Robert Bergh – 5.426</li>



<li>Åke Svanstedt – 5.384</li>



<li>Timo Nurmos – 3.888</li>



<li>Peter Untersteiner – 3.677</li>



<li>Jan-Olov Persson – 3.325</li>



<li>Jim Frick – 3.187</li>



<li>Kari Lähdekorpi – 3.048</li>



<li>Björn Goop – 3.028</li>
</ol>



<p class="wp-block-paragraph"><em>Statistiken gäller segrar med svensk licens.</em><br><strong>Källa: </strong>Nordiska travmuséet</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/2022/10/pureatlas-617x333.jpg" alt="" class="wp-image-365969"/><figcaption class="wp-element-caption">Pure Atlas och Örjan Kihlström. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Eftermiddagens högst doterade lopp är Scandal Plays Minne över lång distans och där plockar en av tipsexperternas i Sulkysports panel ett spikförslag – och <strong>Pure Atlas</strong> är inte ens favorit i loppet.<br><em>”Fredrik Wallin har en tuffing i Pure Atlas. Startgaloppen senast lämnade ett par frågetecken, men dessa har Wallin rätat ut och nu ställs han inför en passande uppgift. Lång distans passar fint och utan häst på utsidan i volten är inte fjärdespåret något problem. Rikard N Skoglund får leta rätt ryggar – sedan fäller Pure Atlas samtliga till slut!”, </em>lyder motiveringen.</p>



<p class="wp-block-paragraph">Sulkysports expertpanel har synat omgången och levererar sina bästa spikar och roliga skrällar i SM-omgången i Boden – <a href="https://sulkysport.se/spelstugan/v85-tips-bo-3-okt" target="_blank" rel="noreferrer noopener">kolla in V85-dragen här!</a></p>



<p class="wp-block-paragraph"><em>Vill du spela andelsspel tillsammans med Sulkysports panel? Här finns olika alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/butik/simsalabim/V85_2026-10-03_11_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Simsalabim.</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/butik/69ansspel/V85_2026-10-03_11_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos 69:ans Spel &#038; Tobak.</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/butik/spelpoolen/V85_2026-10-03_11_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Spelpoolen.</a></p>



<p class="wp-block-paragraph">Travlördagen börjar redan med lunchtrav på Åby (första start 11.10) idag.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/10/261003.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>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/08/080826r11apex-617x374.jpg" alt="" class="wp-image-883784"/><figcaption class="wp-element-caption">Invändige Apex vinner Hambletonian Stakes 2026 på Meadowlands före Big Ranger. Foto: Lisa Photo</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3Tio gånger har svenska tränare vunnit Kentucky Futurity ($575.000) på Red Mile och mycket talar för en ny seger ikväll. Tio av elva hästar tränas nämligen av blågula tränare.</p>



<p class="wp-block-paragraph">På papperet är revanschmötet mellan Marcus Melanders <strong>Apex</strong> (e. Walner) och Anette Lorentzons <strong>Big Ranger </strong>(e. In Range) från Hambletonian Stakes ($1.000.000) det stora samtalsämnet, men det finns flera andra hästar som vill ha ett ord med i sammanhanget.</p>



<p class="wp-block-paragraph">Marcus Melanders <strong>Nix Nacken </strong>(e. Muscle Hill) besegrade ju Apex i Canadian Trotting Classic (C$590.000) på Mohawk Raceway och Lucas Wallins <strong>Inexpressable </strong>(e. Walner) kommer närmast från seger i finalen i Kentucky Sire Stakes Championship ($400.000) på Red Mile.</p>



<h2 class="wp-block-heading">Tidigare svensktränade vinnare i Kentucky Futurity:</h2>



<p class="wp-block-paragraph"><strong>År – Namn (far) – Körsven/tränare</strong></p>



<ul class="wp-block-list">
<li>1990 – <strong>Star Mystic </strong>(e. Mystic Park) – Jan Johnson</li>



<li>1994 – <strong>Bullville Victory</strong> (e. Valley Victory) – John Campbell/Per Eriksson</li>



<li>1997 – <strong>Take Chances</strong> (e. Super Bowl) – Wally Hennessey/Jimmy Takter</li>



<li>2000 – <strong>Credit Winner </strong>(e. American Winner) – Jim Meittinis/Per Eriksson</li>



<li>2014 – <strong>Nuncio </strong>(e. Andover Hall) – John Campbell/Jimmy Takter</li>



<li>2015 – <strong>Pinkman </strong>(e. Explosive Matter) – Yannick Gingras/Jimmy Takter</li>



<li>2018 – <strong>Six Pack</strong> (e. Muscle Mass) – Åke Svanstedt</li>



<li>2019 – <strong>Greenshoe </strong>(e. Father Patrick) – Brian Sears/Marcus Melander</li>



<li>2022 – <strong>Rebuff </strong>(e. Muscle Hill) – Tim Tetrick/Lucas Wallin</li>



<li>2023 – <strong>Tactical Approach</strong> (e. Tactical Landing) – Scott Zeron/Nancy Takter</li>
</ul>



<p class="wp-block-paragraph">I stoavdelningen – Kentucky Futurity Filly ($300.000) – är åtta hästar tränade av svenskar, varav två är svenskfödda. Marcus Melanders <strong>Nezuko Kamado</strong> (e. Chapter Seven) är redan dollarmiljonär med seger i Hambletonian Oaks ($500.000) som främsta merit under 2026. Startar gör också <strong>Frattina Diablo</strong> (e. Captain Corey), vilken bytt tränare efter senaste starten från Tony Alagna till Ronald Best.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/08/nezukokamadoygm260808adamstromstalltz-617x414.jpg" alt="" class="wp-image-883790"/><figcaption class="wp-element-caption">Nezuko Kamado håller undan till seger i Hambletonian Oaks före Carve. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Ifjol blev det seger för Lucas Wallin-tränade <strong>Delaney Hanover </strong>(e. Muscle Hill) i Kentucky Futurity Filly och det var den 14:e blågula tränarsegern i loppet. Nämnas ska också att en svenskfödd travare vunnit det amerikanska travderbyt för ston. <strong>Jiggy Jog </strong>(e. Walner) vann 2022 i regi Åke Svanstedt och hon kördes till seger av Dexter Dunn på löpningsrekordet 1.08,4.</p>



<p class="wp-block-paragraph"><strong>Kentucky Futurity</strong> ($575.000)<br>Treåringar.<br><em>1.609 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Kusk/tränare</strong></p>



<ol class="wp-block-list">
<li><strong>Nix Nacken </strong>(e. Muscle Hill) – Björn Goop/Marcus Melander</li>



<li><strong>American Power</strong> (e. Walner) – James MacDonald/Marcus Melander</li>



<li><strong>Ai </strong>(Chapter Seven) – Ronnie Wrenn Jr/Ron Burke</li>



<li><strong>Read the Room</strong> (e. Chapter Seven) – Åke Svanstedt</li>



<li><strong>Neighver Punt </strong>(e. Bar Hopping) – Örjan Kihlström/Marcus Melander</li>



<li><strong>Inexpressable</strong> (e. Walner) – Scott Zeron/Lucas Wallin</li>



<li><strong>Apex </strong>(e. Walner) – Dexter Dunn/Marcus Melander</li>



<li><strong>Magic Punk </strong>(e. Wishing Stone) – Yannick Gingras/Åke Svanstedt</li>



<li><strong>Big Ranger </strong>(e. In Range) – Tim Tetrick/Anette Lorentzon</li>



<li><strong>Zephyr Kemp</strong> (e. Calgary Games) – Todd McCarthy/Marcus Melander</li>



<li><strong>Spencer Hanover</strong> (e. Chapter Seven) – Jason Bartlett/Marcus Melander</li>
</ol>



<p class="wp-block-paragraph"><strong>Kentucky Futurity Filly</strong> ($300.000)<br>Treåriga ston.<br><em>1.609 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Kusk/tränare</strong></p>



<ol class="wp-block-list">
<li><strong>Godusa </strong>(e. Ready For Moni) – Todd McCarthy/Nancy Takter</li>



<li><strong>Nuance</strong> (e. Greenshoe) – James MacDonald/Marcus Melander</li>



<li><strong>Madam Cheval </strong>(e. Walner) – Tim Tetrick/Nancy Takter</li>



<li><strong>Custom </strong>(e. Walner) – Jason Bartlett/Petter Engblom</li>



<li>Frattina Diablo (e. Captain Corey) – Ronnie Wrenn Jr/Ronald Best</li>



<li><strong>Carve</strong> (e. Captain Corey)– Noel Daley</li>



<li><strong>R Ro</strong> (e. Chapter Seven) – Andy Miller/John Butenschoen</li>



<li><strong>Nezuko Kamado</strong> (e. Chapter Seven) – Scott Zeron/Marcus Melander</li>



<li><strong>Leading Lady</strong> (e. Walner) – Joe Bongiorno/Nancy Takter</li>



<li><strong>Setyoursightshigh</strong> (e. In Range) – Dexter Dunn/Marcus Melander</li>



<li><strong>She’s Moni </strong>(e. Walner) – Yannick Gingras/Nancy Takter</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/2026/09/superchapter091226mikelizzi1024px-617x347.jpg" alt="" class="wp-image-897434"/><figcaption class="wp-element-caption">Super Chapter försvinner ifrån till en överlägsen triumf för Dexter Dunn i VM-loppet. Foto: Mike Lizzi</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4Världsmästaren <strong>Super Chapter </strong>(e. Chapter Seven) gör sin första start efter segern i Yonkers Internatonal Trot ($1.000.000) på Yonkers Raceway i natt svensk tid, men Marcus Melanders häst ställs inte mot något enkelt motstånd i<a href="https://racing.ustrotting.com/goto.aspx?target=12,105904" data-type="link" data-id="https://racing.ustrotting.com/goto.aspx?target=12,105904" target="_blank" rel="noreferrer noopener">Dayton Trotting Derby Grand Circuit Stake </a>($250.000) på Hoosier Park.</p>



<p class="wp-block-paragraph">Bland motståndarna finns världens snabbaste travare på milebana – <strong>On To Norway </strong>(e. Muscle Massive) – och i startlistan finns även Åke Svanstedt och <strong>Up Your Deo</strong> (e. Walner), men också Nancy Takter-tränade <strong>French Wine </strong>(e. Bar Hopping).</p>



<p class="wp-block-paragraph">Stona tävlar om lika stora pengar i <a href="https://racing.ustrotting.com/goto.aspx?target=12,105905" data-type="link" data-id="https://racing.ustrotting.com/goto.aspx?target=12,105905" target="_blank" rel="noreferrer noopener">Dayton Oaks Derby Grand Circuit Stake</a> ($250.000) och där startar fem svensktränade hästar; Petter Engbloms <strong>Bravo Angel </strong>(e. Readly Express), Marcus Melanders duo <strong>Bourbonista</strong> (e. Face Time Bourbon) och <strong>Tactical Moni </strong>(e. Tactical Landing) plus Åke Svanstedts <strong>Warrawee Michelle</strong> (e. Walner) och Lucas Wallins <strong>Delaney Hanover </strong>(e. Muscle Hill).</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/11/3daimbrodda-617x333.jpg" alt="" class="wp-image-655173"/><figcaption class="wp-element-caption">Daim Brodda och Eirik Höitomt. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5Efter andraplatsen på 1.08,8a/1.609 meter bakom världens snabbaste travare Allegiant i Hugo Åbergs Memorial har det följt två tyngre uppgifter på svensk mark för norsktränade toppstoet <strong>Daim Brodda</strong> (e. Readly Express). Först slutade hon åtta i Sto-EM på Solvalla och i Sto-SM häromveckan blev hon oplacerad från ledningen. Däremellan tackade kretsen runt hästen nej till start i VM-loppet på Yonkers med anledning av den skrala insatsen på Solvalla.</p>



<p class="wp-block-paragraph">Ikväll på Bjerke (första start 18.30) tar Kjetil Helgestad sto nya tag när hon kommer ut i en stoelit och möter sex motståndare. Medeldistans och startbil är förutsättningarna och Daim Brodda – som vanligt med Eirik Höitomt i vagnen – inleder från spår sex.<br>Fyra konkurrenter är precis som Daim Brodda svenskfödda och bland dessa finns Patrik Olsson-tränade <strong>Kaffeåchampagne</strong> (e. Butler). Åbyamatören sitter själv i vagnen från spår fyra bakom bilen. Övriga svenskfödda är <strong>Maharasha</strong> (e. Maharajah), <strong>Coral Coger</strong> (e. Ken Warkentin) och <strong>Konstantia Sisu</strong> (e. Maharajah).</p>



<p class="wp-block-paragraph"><a href="https://www.travsport.no/travbaner/bjerke-travbane/startlist/2026-10-03" target="_blank" rel="noreferrer noopener">Här är startlistorna till Bjerkes tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">6I onsdags vann Thomas Malmqvist-tränade, danskfödda <strong>Nova Game</strong> (e. Calgary Games) Breeders Course-finalen för tvååriga ston på Jägersro och slog in en halv miljon kronor.<br>I eftermiddag kan ett annat sto från stallet lägga beslag på en stor prischeck. <strong>Nachos D.K.</strong> (e. Howdy Partner) startar i Jydsk 2-årings Grand Prix med 150.000 danska kronor i förstapris i Århus.</p>



<p class="wp-block-paragraph">Nachos D.K. har gjort två starter hittills och kommer närmast från vinst i ett tvååringslopp i Halmstad så sent som i månadgs. Då travade hon 1.18,5/1.640 meter vid lätt vinst från ledningen. Ken Ecce sitter i vagnen idag, precis som senast.</p>



<p class="wp-block-paragraph">Den som visat mest i fältet är Flemming Jensen-tränade <strong>Ninjago</strong> (e. Maharajah), som vunnit två av tre starter. Vid enda förlkusten slutade han tvåa på Charlottenlund bakom vinnaren av Breeders Course-finalen för hingstar och valacker, Nassir Dust (e. Greenshoe).</p>



<p class="wp-block-paragraph"><strong>Startlista Jydsk 2-årings Grand Prix</strong><br>1.800 meter autostart, Århus lördag<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li><strong>Nachos D.K.</strong> (e. Howdy Partner) – Ken Ecce</li>



<li><strong>Nice Gardenia</strong> (e. Great Challenger) – Rene Kjaer</li>



<li><strong>Nabucco</strong> (e. Bird Parker) – Casper M Nielsen</li>



<li><strong>Naughty Cash</strong> (e. Italiano Vero) – Knud Mönster</li>



<li><strong>New Watch</strong> (e. Readly Express) – Patrick Larsen</li>



<li><strong>Nipz</strong> (e. Maharajah) – Nicklas Korfitsen</li>



<li><strong>Nilsson</strong> (e. Fabulous Wood) – Jeppe Juel</li>



<li><strong>Notre Histoire</strong> (e. Father Patrick) – Jim Veldman</li>



<li><strong>Nachos Cash</strong> (e. Italiano Vero) – Birger Jörgensen</li>



<li><strong>Ninjago</strong> (e. Maharajah) – Flemming Jensen</li>



<li><strong>Ny Komet</strong> (e. Forever Peace) – Kasper Foget</li>
</ol>



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



<figure class="wp-block-image size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2025/09/skarmavbild20250922kl.14.41.35-350x201.jpg" alt="" class="wp-image-770631"/><figcaption class="wp-element-caption">Midnight Sun går undan säkert för Alexis Collette vid en tidigare seger.</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">7Två svenskfödda travare gör debut på fransk mark idag. David Persson och Elke Frinta plockar nämligen ut <strong>Kash Keeper</strong> (e. Uncle Lasse) respektive <strong>Without a Doubt</strong> (e. Hard Livin) i montéloppet Prix de Precey (€29.000) över 2.750 meter med 13.050 euro till vinnaren.</p>



<p class="wp-block-paragraph">Det handlar om ett välbetalt lärlingslopp och Kash Keeper har tävlat en hel del under sdel i Sverige, där 15 starter givit fyra segrar.  För Without a Doubt är det första starten sedan augusti förra året och dessutom både debut i Frintas regi samt första starten i monté.</p>



<p class="wp-block-paragraph">Mer blågult blir det i fyraåringsloppet Prix de Cernay (€22.000), där Jarmo Niskanen startar egenägda <strong>Maharani</strong> (e. Earl Simon), som jagar livets första seger.</p>



<p class="wp-block-paragraph"><a href="https://www.letrot.com/courses/programme/2026-10-03/1475" target="_blank" rel="noreferrer noopener">Här är startlistorna till tävlingarna i Cabourg.</a></p>



<p class="wp-block-paragraph">Till Laval sänder Jörgen Westholm franske fyraåringen <strong>Midnight Sun</strong> (e. Helgafell), som står perfekt inne på pengarna i ett sulkylopp med 9.45 euro till vinnaren. Midnight Sun vann två lopp i Sverige förra hösten och följde upp med två vinster på fransk mark i vintras på sammanlagt åtta starter i karriären. Nu är han tillbaka på banan för första gången sedan i slutet av januari. Alexis Collette kör, precis som vid de tidigare triumferna i Frankrike.</p>
