
<p class="has-drop-cap wp-block-paragraph">1Många fina travnamn hyllas och hedras på Hagmyren (första start 13.30) idag. Som Ernst Johan Nordin (1887–1957. Han lade grunden till en dynasti inom svensk och internationell travsport, där sönerna Gösta, Gunnar och Sören kom att dominera i långt mer än ett halvt sekel. Efter att ha verkat som tränare i Näsviken i Hälsingland flyttade Ernst Johan söderut till Solvalla där han bland annat blev kuskchampion 1929.</p>



<p class="wp-block-paragraph">Sedan 1965 hedras ”balanseringskonstens mästare” med E.J.’s Guldsko på Hagmyren och två gånger har vinnaren travat under 1.10. Löpningsrekordet har Daniel Wäjerstens numera pensionerade mångmiljonär <strong>Global Badman</strong> (e. Yield Boko), som travade 1.09,8 för två år sedan.</p>



<p class="wp-block-paragraph">I eftermiddag kan inte Wäjersten själv putsa rekordet trots tre hästar av sju i årets upplaga av E.J.’s Guldsko – han är nämligen på plats i New York för att köra <strong>Mellby Jinx</strong> (e. Ready Cash) i VM-loppet på Yonkers Raceway.</p>



<p class="wp-block-paragraph">Wäjerstens trio i gulddivisionen på Hagmyren är <strong>Before Takeoff</strong> (e. Nuncio), <strong>Lando Mearas</strong> (e. Walner) och <strong>Mellby Joker</strong> (e. Muscle Hill) – och de tre är de mest spelade hästarna i loppet. Wäjerstens försteman Oskar Flodhed håller ställningarna på hemmaplan och lyfter fram sin vinnare i trion:<br>– Lando Mearas är den jag tror mest på av våra tre. Han fick aldrig chansen på Romme senast och klättrade i ryggar senast över mål med gott om krafter kvar. Det var ett nyttigt och bra uppbyggande lopp han fick där. Tidigare har han varit ute mot tuffa hästar och gjort det bra. Han är väldigt startsnabb och spår fem på Hagmyren är bra mitt i banan, säger Florhed till Kanal75.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/09/12v85.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Hagmyrens 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/06/majblomsterjop-617x333.jpg" alt="" class="wp-image-863217"/><figcaption class="wp-element-caption">Majblomster tillsammans med sin tränare Jan-Olov Persson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Sex gånger har Jan-Olov Persson tränat vinnare i Sto-SM för kallblod. Det har ingen annan tränare lyckats med tidigare. Idag kan han säkra en sjunde titel om megafavoriten <strong>Majblomster</strong> (e. Tekno Odin) står pall för trycket.</p>



<p class="wp-block-paragraph"><strong>Tränartoppen i Sto-SM för kallblod:</strong></p>



<ul class="wp-block-list">
<li>Jan-Olov Persson – 6 – Stjärnblomster (4), Järvsö Blomster (2)</li>



<li>Gunnar Melander – 3 – Gejser (1), Nordblomma (1), Nordvanja (1)</li>



<li>Hans Brunlöf – 2 – Jenny R.G. (2)</li>



<li>Håkan Åslund – 2 – Lundås Emelie (2)</li>
</ul>



<p class="wp-block-paragraph">I Sulkysports expertpanel lyfts Majblomster fram som ett spikförslag i jackpotomgången där en ensam vinnare kan få minst 32 miljoner kronor enligt ATG:s prognos. Sä här låter det om Majblomster:<br><em>”Sveriges snabbaste och vinstrikaste kallblodssto genom tiderna – jag krånglar inte till det i Sto-SM. Majblomster har haft en stark säsong och kommer närmast från silverpengen i öppna SM mot hingstar och valacker. Förra året var inte formen helt på topp i Sto-SM, men i år finns inga som helst frågetecken för detta. Hon kan öppna bra och chansen är god att hon försvarar ledningen från innerspår. Annars får Mats E Djuse leta sig ut i fritt slagläge och avgöra. En given spik!”</em></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v85-jackpot-h-12-sep/" target="_blank" rel="noreferrer noopener">––> Här är experternas tips till Hagmyrens V85-omgång.</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-09-12_17_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-09-12_17_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-09-12_17_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Spelpoolen.</a></p>



<p class="wp-block-paragraph">Kvällen på svensk mark avslutas i Kalmar (första start 18.50), där det är sista chansen att kvala in till banans stayer- och stoserie. Långloppens final har de senaste två åren vunnits av <strong>A Fair Day</strong> (e, Maharajah) och nu ska lillebror <strong>Maroon Day </strong>(e. Maharajah) säkra en plats i finalen i Kalmar den 2 oktober med 125.000 kronor i förstapris.</p>



<p class="wp-block-paragraph">Örebro (första start 11.10) inleder lördagen med breddloppstävlingar. Hela 131 hästar anmäldes till delningspropositionen och 108 hästar får chansen i de prishöjda loppen med 15.000 kronor i förstapris.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/09/260912.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/2021/06/mellbyjinx2-617x333.jpg" alt="" class="wp-image-176034"/><figcaption class="wp-element-caption">Mellby Jinx. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3Världsmästerskapet i trav som en gång i tiden instiftades på Roosevelt Raceway 1959 och som arrangerades på numera nerlagda Long Island-banan och där svenskfödde <strong>Callit</strong> tog hem den sista upplagan 1987.</p>



<p class="wp-block-paragraph">Därefter flyttades loppet till grannbanan Yonkers Raceway och hölls åren 1988-1995 med undantag för 1994 innan loppet gick i graven för att återuppstå 2015. Fem upplagor hanns med, men när covid-19 slog till i början av 2020 valde banans ägare att lägga ner det prestigefyllda loppet av ekonomiska skäl.</p>



<p class="wp-block-paragraph">2022 var ”International Trot” tillbaka och slutade med seger för norskfödde <strong>Cokstile</strong> (e. Quite Easy) och för två år sedan dominerade Åke Svanstedt-tränade <strong>Jiggi Jog</strong> (e. Walner-Hot Mess Hanover), 1.08,0*/$3.100.467, tillsammans med Dexter Dunn och ordnade första vinsten för en svenskfödd travare på 29 år. <strong>Twister Bi</strong> (e. Varenne) har löpningsrekordet med 1.10,7a/2.011 meter noterat tillsammans med Christoffer Eriksson 2017.</p>



<p class="wp-block-paragraph">En miljon dollar ligger i prispotten och vinnaren tar hälften när årets upplaga avgörs på Yonkers Raceway ikväll svensk tid.<br>Det är en hel del svenskanknytningar bland de tio deltagarna på Yonkers. Fyra hästar är svenskfödda (Bourbonista, Mellby Jinx, Antognoni, Betting Pacer), sex är svensktränade (Gio Cash, Bourbonista, Super Chapter, Mellby Jinx, Diva Ek, Betting Pacer) och tre körs av svenska kuskar (Mellby Jinx, Powwow, Betting Pacer).</p>



<p class="wp-block-paragraph">Daniel Wäjersten, Marcus Melander och Ron Burke dominerar bland tränarna med två hästar vardera.<br>– Vi har två fina hästar. Jag tycker att Gio Cash borde ha samma form som förra året och Mellby Jinx har ju varit bra i princip varje gång som han har startat, så det är spännande. Gio Cash får gärna komma till ledningen den här gången, men vi får se lite. Vi körde med skor fram i fjol, i och med att den banan är lite hård. Vi får se om den är lite mjukare i år. Det skulle vara ett plus om han kan gå barfota runt om, säger Daniel Wäjersten till Kanal75.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/dags-for-en-ny-svensk-vm-hjalte/" target="_blank" rel="noreferrer noopener">––> Läs mer om VM-loppets historia från premiären 1959 till idag här!</a></p>



<p class="wp-block-paragraph"><strong>Startlista Yonkers International Trot ($1.000.000)<br></strong>2.011 meter, autotart.<br><em>Häst (far) – Kusk/tränare</em></p>



<ol class="wp-block-list">
<li><strong>Lexus Kody</strong> (e. Archangel) – Jason Bartlett/Ron Burke</li>



<li><strong>Gio Cash</strong> (e. Victor Gio) – Robin Bakker/Daniel Wäjersten</li>



<li><strong>Hooker Berry</strong> (e. Booster Winner) – Antoine Lhéréte</li>



<li><strong>Bourbonista</strong> (e. Face Time Bourbon) – Scott Zeron/Marcus Melander</li>



<li><strong>Super Chapter</strong> (e. Chapter Seven) – Dexter Dunn/Marcus Melander</li>



<li><strong>Mellby Jinx</strong> (e. Ready Cash) – Daniel Wäjersten</li>



<li><strong>Powwow</strong> (e. Papagayo E.) – Åke Svanstedt/Jan Kristian Waaler</li>



<li><strong>Diva Ek</strong> (e. Trixton) – Alessandro Gocciadoro</li>



<li><strong>Antognoni</strong> (e. Father Patrick) – Yannick Gingras/Ron Burke</li>



<li><strong>Betting Pacer</strong> (e. Maharajah) – Björn Goop</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">4Sandra Erikssons fyraåringsston Tekla (e. Teklno Odin) har vunnit både norska Stokriteriet och Derbystoet i Östersund, men det blir ingen tredje titel. Sandra tvingades stryka den imponerande försöksvinnaren sedan Tekla varit halt när hon togs in från hagen i söndags.</p>



<p class="wp-block-paragraph">När Bjerke – och Norge – bjuder på fyra klassiska finaler för för ston saknas helgens största hoop.</p>



<p class="wp-block-paragraph">Fast Bjerke (första start 14.10) bjuder på andra godbitar, främst i treåringklasserna,. där två obesegrade ston ska försöka knipa sina första klassiska triumfer: Express Go (e. Readly Express) respektive Förlands Lilja (e. Bork Odin). </p>



<p class="wp-block-paragraph">Nio repsektive sex segrar på raken har de två toppstona,</p>



<p class="wp-block-paragraph"><strong>Svensktränade finalister – lördag</strong><br><em>Stoderbyt, kallblod – förstapris 795.627 NOK:</em></p>



<ul class="wp-block-list">
<li>Ängsmolly (e. Norheim Faksen) – Kajsa Frick</li>



<li>Komnes Fina (e. Tekno Odin) – Jan-Olov Persson</li>
</ul>



<p class="wp-block-paragraph">42 varmblod och 32 kallblod var anmälda till den norska Derbyauktionen på Bjerke ikväll och efter strykningar återstår 66 ettåringar. Det handlar om en så kallad hybridauktion med både digital och fysisk budgivning på plats på Bjerkes restaurang.</p>



<p class="wp-block-paragraph">Här går det att följa auktionen under kvällen.</p>



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



<p class="has-drop-cap wp-block-paragraph">5Idag ska det avgöras. Vilka hästar i bäst i respektive kull bland tre- fyra- och femåringarna i Frankrike? Ja, det säger inte hela sanningen, men historiskt sett så har de stora stjärnorna varit framgångsrika i Criterium des 3,4, och 5 ans (€300.000) på Vincennes och Parisbanan Vincennes har gjort ett evenemang som folket ska längta till här i mitten av september.</p>



<p class="wp-block-paragraph">Alla de största stjärnorna i respektive kull är faktiskt inte med i Paris idag, men deltagarlistan är stark i samtliga tre lopp. Av fjolårsvinnarna finns till exempel <strong>Mack de Blary</strong> (e. Face Time Bourbon) och <strong>Lancier du Goutier</strong> (e. Ready Cash) med. Thierry Duvaldestins båda stjärnor vann loppen för tre- och fyraåringar ifjol och har så klart klättrat ett pinnhål på åldersstegen till i år.</p>



<p class="wp-block-paragraph">För treåringarna kan det mycket väl handla om en batalj mellan Duvaldestin-tränade hästar och charmiga <strong>Nocive du Choquel</strong> (e. Face Time Bourbon). Hästen har agerat skräll i två av de tidigare grupp-loppen på Vincennes, men den här gången lär spelarna knappast låta bli att lägga ett lir på henne. Nicolas Bridaults lilla travare Nocive du Choquel har snuddat vid farter som den äldre eliten travar över lång distans på Vincennes och det vore inte orättvist om stoet lyckas besegra sina manliga och kvinnliga kullkamrater även idag.</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/09/scoopdyga126541016-617x411.jpg" alt="" class="wp-image-893404"/><figcaption class="wp-element-caption">Florian Desmigneux och Ruger vid senaste segern i La Capelle. Foto: Scoop Dyga</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6I skymundan av de stora, franska årgångsloppen dyker fem svenskfödda travare upp på kolstybben. Jägersroamatören Elke Frinta satsar på hästar uppstallade i Frankrike och duon  <strong>Perfekt</strong> (e. Southwind Frank) och <strong>Peak of Glory </strong>(e. Muscle Mass) i ett stolopp med 60.000 euro i potten, varav 27.000 euro till vinnaren.<br>Perfect har testat nio gånger i Frankrike och tog sin seger vid första försöket på Enghien, medan Peak of Glory gör sin andra start i Paris.</p>



<p class="wp-block-paragraph">Ett tredje svenskt sto tillhör favoriterna i loppet. Vitale Ciotola tränar <strong>Lovely Wilma</strong> (e. Flocki d’Aurcy), som vunnit tre av sju starter i Frankrike och hade en fin sommar på Enghien. Nu har hon vilat 1,5 månader inför den här uppgiften.</p>



<p class="wp-block-paragraph">Ett annat stolopp med 26.550 euro i förstapris avslutar tävlingsdagen med ytterligare två svenskfödda damer till start: Erik Bondotränade <strong>Toscana Southwind</strong> (e. Bold Eagle) och Pierre Levesques <strong>Junkie</strong> (e. Varenne).</p>



<p class="wp-block-paragraph"><a href="https://www.letrot.com/courses/programme/2026-09-12/7500" target="_blank" rel="noreferrer noopener">Här är startlistorna till Vincennes tävlingar idag.</a></p>



<p class="wp-block-paragraph">Gävletränaren Erik Lindegren har firat stora framgångar i Frankrike med <strong>Ruger</strong> (e. Readly Express), som vunnit sex lopp och sprungit in cirka 1,4 miljoner kronor på 22 starter på fransk mark. Detta har skett med andra kuskar än tränare Lindegren, men i eftermiddag är det dags!<br>I Prix de Bel Air (€28.000) över 3.000 meter med 12.600 euro till vinnaren på Salon de Provance jagar Ruger fjärde raka segern och för första gången ska Lindegren köra lopp i Frankrike.</p>



<p class="wp-block-paragraph">Det tävlas på fler franska banor och ikväll reser Jarmo Niskanen till Vichy med treårige <strong>Ninos</strong> (e. Earl Simon), som jagar första segern i fjärde försöket. </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/09/kountryplunge090426fotowon1024-617x347.jpg" alt="" class="wp-image-894528"/><figcaption class="wp-element-caption">Kountry Plunge vinner för Brian Sears. Foto: Fotowon Photo</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">7Det är inte bara VM-loppet – Yonkers International Trot ($1.000.000) – som avgörs på Yonkers Raceway utan också finaler i New York Sire Stakes ($300.000) för två- och treåringar. </p>



<p class="wp-block-paragraph">Hela tio svensktränade travare startar i finalerna och bland dem finns Åke Svanstedts obesegrade auktionsdyring Kountry Plunge (e. Chapter Seven), 1.11,0*/$127.100, som är på jakt efter sin femte raka triumf. </p>



<p class="wp-block-paragraph"><strong>Tvååriga hingstar/valacker:</strong></p>



<ul class="wp-block-list">
<li>Bigtime Chapter (e. Chapter Seven) – Marcus Melander</li>



<li>Gio’s Hope (e. Chapter Seven) – Marcus Melander</li>
</ul>



<p class="wp-block-paragraph"><strong>Tvååriga ston: </strong></p>



<ul class="wp-block-list">
<li>Anabella (e. Chapter Seven) – Nancy Takter</li>



<li>Kountry Plunge (e. Chapter Seven) – Åke Svanstedt</li>



<li>Secret Lover (e. Chapter Seven) – Marcus Melander</li>
</ul>



<p class="wp-block-paragraph"><strong>Treåriga hingstar/valacker:</strong></p>



<ul class="wp-block-list">
<li>Read the Room (e. Chapter Seven) – Åke Svanstedt</li>



<li>Seven Grand (e. Chapter Seven) – Åke Svanstedt</li>
</ul>



<p class="wp-block-paragraph"><strong>Treåriga ston:</strong></p>



<ul class="wp-block-list">
<li>Flying Copper (e. Chapter Seven) – Åke Svanstedt</li>



<li>Jula Hot To Chill (e. Chapter Seven) – Marcus Melander</li>



<li>Who Dares Wins (e. Chapter Seven) – Åke Svanstedt</li>
</ul>



<p class="wp-block-paragraph">På Yonkers Raceway avgörs också Bob Mecuna Invitational Trot ($200.000) över 2.011 meter – samma som VM-distansen – och där startar Marcus Melanders <strong>Aetos Kronos</strong> (e. Bold Eagle), Petter Engbloms Devilish Hill (e. Muscle Hill) och Åke Svanstedts <strong>Up Your Deo</strong> (e. Walner). </p>



<p class="wp-block-paragraph"><a href="https://racing.ustrotting.com/goto.aspx?target=12,105616" target="_blank" rel="noreferrer noopener">Startlistorna till Yonkers Raceways hittar du här. </a></p>
