
<p class="has-drop-cap">1 <strong>Åke Svanstedt</strong> kunde inte rå på omöjlige <strong>Ron Burke</strong>, men när den nordamerikanska Grand Circuit-säsongen avlutades i och med Progress Pace på Dover i Delaware den här veckan stod det klart att Svanstedt är den näst mest framgångsrike tränaren under året. I Grand Circuit-lopp alltså.</p>



<p><strong>Marcus Melander</strong> har haft ett magnifikt 2025 han också och han knep tredjeplatsen bland tränarna. Av kuskarna har <strong>Dexter Dunn</strong> varit mest framgångsrik och han avgjorde ligan före <strong>Yannick Gingras</strong> och <strong>Jason Bartlett</strong>.</p>



<p>Åke Svanstedt är med bland de tio främsta i de tre listor som sammanställts efter årets Grand Circuit-säong. Bland kuskarna placerade sig Åke på plats nio, medan hans ägarskap Åke Svanstedt Inc. slutade sexa. Burke Racing Stable LLC tog hem titeln bland ägarna där också <strong>Courant Inc</strong> varit framstående, så pass att Anders Ströms bolag blev fjärde bästa ägaren 2025.</p>



<p>Åke Svanstedts största seger under 2025 var förstås den i Hambletonian med <strong>Nordic Catcher S</strong> (e. Six Pack). </p>



<h2 class="wp-block-heading">Bästa tränare i GC 2025</h2>



<p>Tränare – poäng</p>



<ol class="wp-block-list">
<li>Ron Burke – 4.970</li>



<li>Åke Svanstedt – 2.518,5</li>



<li>Marcus Melander – 2.402,5</li>



<li>Noel Daley – 1.670</li>



<li>Chris Ryder – 1.329,5</li>



<li>Per Engblom – 1.263</li>



<li>Nancy Takter – 1.108,5</li>



<li>Luc Blais – 907</li>



<li>Brett Pelling – 884</li>
</ol>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2024/09/skarmavbild20240922kl.12.43.38-617x648.jpg" alt="" class="wp-image-637297" style="width:666px;height:auto"/><figcaption class="wp-element-caption">Marcus Melander och Dexter Dunn efter Marylands seger i Mohawk Million förra året. Foto: New Image Media</figcaption></figure>



<h2 class="wp-block-heading">Bästa kuskar GC 2025</h2>



<p>Kusk – poäng</p>



<ol class="wp-block-list">
<li>Dexter Dunn – 4.371,5</li>



<li>Yannick Gingras – 3.112,5</li>



<li>Jason Bartlett – 2.774,5</li>



<li>Scott Zeron – 2.684,5</li>



<li>Tim Tetrick – 2.417</li>



<li>Todd McCarthy – 2.409</li>



<li>Andrew McCarthy – 1.847,5</li>



<li>David Miller – 1.770,5</li>



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



<li>James MacDonald – 1.479</li>
</ol>



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



<p class="has-drop-cap">2 150.000 kronor väntar vinnarna i kvällens finaler i tre- och fyraåringsserien i <strong>Kalmar</strong> (start 18.20). En Kriterietvåa finns bland de tolv som jagar den prischecken på treåringssidan.</p>



<p>Johan Untersteiner tränar danskfödde <strong>Lazy Dust</strong> (e. Brillantissime), som slutade tvåa i finalen av Danskt Travkriterium i mitten av oktober efter att ha vunnit sitt försök. Kriteriet vanns av Paul Hagoort-tränade stoet Lust For Life (e. Mister J.P.), vilken krossade världsrekordet för treåriga ston över lång distans med startbil när hon travade 1.12,9a/2.500 meter.</p>



<p>Någon motståndare av den kalibern finns inte i kvällens startfält, men för den skull saknas inte duktiga hästar i treåringsfinalen. En av dem är stallkamraten <strong>Digital Brodde</strong> (e. Maharajah) – lillebror till mångmiljonärerna och storloppsvinnarna Daim Brodda och Dancer Brodda. <strong>La Liga Boy</strong> (e. Donato Hanover) har två raka segrar efter att ha köpts av hästägare i Christoffer Erikssons stall, medan fältets näst fattigaste travare, dansktränade <strong>Levelup</strong> (e. Googoo Gaagaa), tog fjärde segern på fem försök när han i senaste starten visade upp sig på svensk mark i Kalmar för första gången.</p>



<p>Endast hästar som deltagit i försök är startberättigade i finalen, där försök körts på Kalmartravet under året. Bland de yngre travarna samlade <strong>Gomari</strong> (e. Raja Mirchi) ihop fler poäng i de sju försöken, medan<strong> Lots of Fun Sisu</strong> (e. Gotland) – som är såld och numera har sin hemvist i Boden hos Jaakko Alamäki – och <strong>Stan Wawrinka</strong> (e. Call Me Keeper) hade flest pong av fyraåringarna efter fem försök.</p>



<p>Förra årets finaler vanns av <strong>Lakethesnake</strong> (e. Ringostarr Treb) och <strong>Maroon Day</strong> (e. Maharajah).</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2024/10/maroonday-617x333.jpg" alt="" class="wp-image-651997" style="width:677px;height:auto"/><figcaption class="wp-element-caption">Elisabeth Almheden-tränade Maroon Day vann Fyraåringsfinalen i Kalmar ifjol. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Utanför V64-kupongen startar Robert Bergh höstens dubble rikstotovinnare <strong>Fangio</strong> (e. Love You) i ett vanligt lopp över lång distans. Bergh väljer själv att tävla på Åby och lämnar över tömmarna till Oscar Ginman.</p>



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



<p class="has-drop-cap">3 Tomas Pettersson är <strong>Bollnästravets</strong> i särklass framgångsrikaste tränare och närmar sig fem miljoner kronor till stallet i år. När Bollnäs (första start 18.30) delar kvällens expresstrav och V64-spel med Kalmar sitter Tomas med bra chanser på förhand.</p>



<figure class="wp-block-image alignright size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2024/07/tomaspetterssonsulky-617x333.jpg" alt="" class="wp-image-613407" style="width:427px;height:auto"/><figcaption class="wp-element-caption">Bollnästränaren Tomas Pettersson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Tre hästar kommer ut och en är femårige <strong>Global Easy Rider</strong> (e. Charly du Noyer), som vann åtta lopp förra säsongen. I år kom första vinsten i andra starten i början av februari, men sedan följde en åtta månader lång period utan triumf. Nu är han tillbaka i vinnarspåret och kommer till dagens start med två raka i bagaget.</p>



<p>Ett annat Pettersson-hopp är treårige <strong>Young Anthony</strong> (e. Orlando Vici), som inlett fint med två segrar och i övrigt enbart pallplatser på fem försök. En tuff motståndare är Matchmadeinheavens (e. S.J.’s Caviar) lillebror <strong>Laststarinheaven</strong> (e. Jocose), som efter 13 starter fortfarande väntar på första segern. Trots att han exempelvis travade 1.12,1a/2.140 meter på Solvallas Kriteriedag.</p>



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



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2019/05/bottnasideal-617x309.jpg" alt="" class="wp-image-44746" style="width:677px;height:auto"/><figcaption class="wp-element-caption">Swish the Cash när han såldes på Elitauktionen 2019 under namnet Bottnas Ideal. Foto Mia Törnberg/Sulkysport</figcaption></figure>



<p class="has-drop-cap">4 Högkapabel, men ack så ojämn. Så kan <strong>Swish The Cash</strong> (e. Ready Cash) beskrivas. I Adrian Kolgjinis regi blev det bland annat dubbla rikstotosegrar och flera imponerande insatser med elva vinster på 49 starter. Däremot gjorde också hästen bort sig med i galopp i mer än hälften av starterna, 25 till antalet.</p>



<p>I början av augusti bytte han regi till Robert Bergh och debuten för nye tränaren slutade på bästa sätt – med felfritt lopp och seger på Åby tävlande barfota runt om. På dagens lunchbana Åby (första start 12.20) – tävlingarna flyttade från Axevalla på grund av vädret – jagar Swish The Cash andra raka segern.</p>



<p>– Han har tagit loppet bra, tränat 1.17/2.000 meter under tävlingspausen. Troligen skor fram och barfota bak, säger Robert Bergh på sin hemsida.</p>



<p>Bland motståndarna finns USA-födde <strong>Take This Society</strong> (e. Muscle Hill), som inte tävlat sedan augusti 2024. Då fanns han i Frode Hamres regi, men nu debuterar han efter lång tid hos Åbytränaren Per Henriksen. Tolv segrar på 50 starter har det blivit hittills – exakt samma resultat som Swish The Cash.</p>



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



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



<figure class="wp-block-image size-sulky-liten2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/09/ontonorwaysep19-350x233.jpg" alt="" class="wp-image-770085" style="width:394px;height:auto"/><figcaption class="wp-element-caption">On To Norway fortsätter att rada upp segrar. Foto: Dean Gillette</figcaption></figure>



<p class="has-drop-cap">5 Inte en fredag utan att en viss <strong>On To Norway</strong> (e. Muscle Massive) ska nämnas i morgonsvepet. Ron Burkes treåring radar vinster som få andra och idag är det seger nummer 23 i rad som jagas. Platsen är Hoosier Park i Indiana och loppet heter The Thanksgiving Classic ($47.700). John De Long sitter som vanligt upp bakom treåringen som i år sprungit in 612.444 USD.</p>



<h2 class="wp-block-heading">Startlista The Thanksgiving Classic</h2>



<p>Häst (far) – Tränare</p>



<ol class="wp-block-list">
<li>Boots N Beer (e. Greenshoe) – Joe Putnam</li>



<li>Siesta Sandman (e. Don&#8217;t Let&#8217;em) – Tyler George</li>



<li>Give Me A Yankee (e. Bar Hopping) – Britney Dillon</li>



<li>Big Shoes (e. Greenshoe) – Ron Burke</li>



<li>Karinchak (e. Chapter Seven) – Ryan Miller</li>



<li>Gimpanzee Dancer (e. Gimpanzee) – Chris Beaver</li>



<li>On To Norway (e. Muscle Massive) – Ron Burke</li>
</ol>



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



<p class="has-drop-cap">6 Treåringar gör upp i Wolvega Cup (€22.000) ikväll och svenskfödde <strong>Fire Starter</strong> (e. Hard Livin), tränad av Wolfgang Nimczyk kan mycket väl vara vinnaren av loppet. Fire Starter har två segrar på fyra starter och är snabbast hittills i elvahästarsfältet med sitt rekord 1.14,1a/1.900 meter.</p>



<p>Svenske <strong>Presley Boko</strong> (e. Tactical Landing) lär också tillhöra favoriterna i händerna på Micha Brouwer. Erwin Bot åker till sitt gamla hemland med italienfödde <strong>Genius Blue Grif</strong> (e. Walner) som tog sin första triumf i Sverigedebuten på Mantorp i maj i år.</p>



<h2 class="wp-block-heading">Startlista Wolvega Cup</h2>



<p>Häst (far) – Kusk</p>



<ol class="wp-block-list">
<li>Pien Starlake (e. Green Manalishi) – Rob de Vlieger</li>



<li>Midnight Sky (e. Victor Gio) – Jeffery Mieras</li>



<li>Presley Boko (e. Tactical Landing) – Micha Brouwer</li>



<li>Genius Blue Grif (e. Walner) – Erwin Bot</li>



<li>Passoa Transs R (e. Robert Bi) – Robin Bakker</li>



<li>Fire Starter (e. Hard Livin) – Robbin Bot</li>



<li>Puck Ballaco (e. Yarrah Boko) – John Dekker</li>



<li>Popcorn Vrijthout (e. Booster Winner) – Thomas Bos</li>



<li>Pantani Renka (e. Bar Hopping) – Bas Crebas</li>



<li>Piet Schermer (e. Explosive Matter) – Dion Tesselaar</li>



<li>Petra S Fortuna (e. Southwind Frank) – André Bakker</li>
</ol>



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



<p class="has-drop-cap">7 Björn Goop hoppar upp bakom David Perssons <strong>Sandokan</strong> (e. Maharajah) när Prix Melusina (€46.000) avgörs över 2.100 meter på Vincennes ikväll. Loppet startas med bil, Sandokan har lottats till spår sex och det är ett tufft gäng som står för motståndet. Efter tre raka vinster i lättare sällskap i södra Frankrike kommer bröderna Martens <strong>Jack du Barbey</strong> (e. Ulysse) till Paris i jakt på större pengar.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2023/01/sandokanelm230104adamstromstalltz-617x395.jpg" alt="" class="wp-image-398386" style="width:548px;height:auto"/><figcaption class="wp-element-caption">Sandokan startar på Vincennes ikväll. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Svenskfödde <strong>Jacques Mearas</strong> (e. Ready Cash) har lämnat Andreas Lövdals stall och finns numera i Erik Bondos regi. Hästen gör debut i Paris i samma lopp och fler svenskfödda travare provar lyckan.<strong> Goodwin Zet</strong> (e. Hard Livin), i finsk regi, kommer att köras av Finlands kuskdominant Santtu Raitala. </p>

Fokustema
Sju nyheter vid sju
Läs senare
Svanstedt på topplistorna
Svanstedts heta GC-säsong. Som tränare, kusk och ägare.
Finaler för tre- och fyraåringar i Kalmar.
23:e i rad väntar i kväll för "Norsken".
Svenskt i Paris. Här är fredagens morgonnyheter.
