
<p class="has-drop-cap">1Vä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>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.<br>2022 var ”International Trot” tillbaka och slutade med seger för norskfödde Cokstile (e. Quite Easy) och ifjol dominerade Åke Svanstedt-tränade <strong>Jiggi Jog</strong> <strong>(</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>En miljon dollar ligger i prispotten och vinnaren tar hälften när årets upplaga avgörs på Yonkers Raceway ikväll svensk tid.</p>



<p>Det är en hel del svenskanknytningar bland de tio deltagarna på Yonkers. Fem av hästarna är svensktränade (Gamin Jaba, Gio Cash, Aetos Kronos, Double Deceiver, Periculum). Fyra av hästarna är svenskkörda (Gamin Jaba, Gio Cash, Powwow och Double Deceiver). Däremot är bara en häst svenskfödd (Aetos Kronos). Dessutom har Diva Ek funnits på Alessandro Gocciadoros svenska filial sedan förra sommaren.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/2danielreden-617x333.jpg" alt="" class="wp-image-722952"/><figcaption class="wp-element-caption">Daniel Redén. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Så här säger Daniel Redén om sin duo:<br>– Båda hästarna har rest bra och som valacker har de fördelen att slippa karantänstallet på Yonkers. De har varit på Marcus Melanders gård sedan i måndags och fick ett tuffare jobb i tisdags på Marcus sandraka. Jag är väldigt nöjd med hur båda känns och spåren blev också bra. Det är klart jag har bra tro på Double Deceiver som han varit på slutet och det verkar även kunna bli tuff körning om spets, så jag hoppas han får ett fint lopp i draget. Gamin sitter bra till i andraspår och jag hoppas få med mig en bit av priskakan. Balansen bestämmer jag när jag får känna på Yonkers underlag, men båda funkar även om det skulle krävas skor, säger Daniel Redén på stall Zets hemsida.</p>



<h2 class="wp-block-heading">Svensktränade/körda vinnare i VM-loppet</h2>



<p><em>År – Namn – Körsven/tränare – Bana</em></p>



<ul class="wp-block-list">
<li>1965 – <strong>Pluvier III</strong> – Gunnar Nordin – Roosevelt Raceway</li>



<li>1987 – <strong>Callit</strong> – Karl O Johansson – Roosevelt Raceway</li>



<li>1989 – <strong>Kit Lobell</strong> – Berndt Lindstedt/Jan Johnson – Yonkers Raceway</li>



<li>1991 – <strong>Peace Corps</strong> – Stig H Johansson– Yonkers Raceway</li>



<li>1992 – <strong>Atas Fighter L. </strong>– Torbjörn Jansson – Yonkers Raceway</li>



<li>1993 – <strong>Giant Force</strong> – John Patterson J:r/Per Eriksson – Yonkers Raceway</li>



<li>1995 – <strong>His Majesty</strong> – Stefan Melander/Catarina Lundström – Yonkers Raceway</li>



<li>2015 – <strong>Papagayo E.</strong> – Ulf Ohlsson/Jan Kristian Waaler – Yonkers Raceway</li>



<li>2016 – <strong>Resolve</strong> – Åke Svanstedt – Yonkers Raceway</li>



<li>2017 – <strong>Twister Bi</strong> – Christoffer Eriksson/Jerry Riordan – Yonkers Raceway</li>



<li>2018 – <strong>Cruzado Dela Noche</strong> – Brian Sears/Marcus Melander – Yonkers Raceway</li>



<li>2024 – <strong>Jiggy Jog</strong> – Dexter Dunn/Åke Svanstedt – Yonkers Raceway</li>
</ul>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/09/yonkersraceway1392025.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Yonkers tävlingar ikväll.</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/05/majblomster1-617x333.jpg" alt="" class="wp-image-723548"/><figcaption class="wp-element-caption">Majblomster på Solvalla. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">2Mamma <strong>Järvsö Blomster</strong> (e. Järvsöviking) vann Svenskt Mästerskap för ston två gånger 2016-2017. Storasyster <strong>Stjärnblomster</strong> (e. B.W.Modde) vann Sto-SM fyra år i rad och avslutade karriären som Sveriges vinstrikaste kallblodssto genom tiderna när hon vann förra året.</p>



<p>I år är det dags för nästa stjärna från familjen. Lillasyster <strong>Majblomster</strong> (e. Tekno Odin) var kullens drottning som tre- och fyraåring och har i år som femåring blivit Sveriges snabbaste sto med 1.19,8a, noterat som fyra i Elitkampen på Solvalla. Nu gör hon debut i SM-sammanhang och ska försöka lägga ytterligare 300.000 kronor till sina tidigare 3.858.517 kronor.</p>



<p><strong>Snabbaste vinnarna av Sto-SM</strong><br><em>År, häst (far) – Kusk (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2011 <strong>Nordblomma</strong> (e. Moe Odin) – Gunnar Melander – 1.23,0a</li>



<li>2024 <strong>Stjärnblomster</strong> (e. B.W.Modde) – Per Linderoth (Jan-Olov Persson) – 1.23,1a</li>



<li>2019 <strong>Minelli</strong> (e. Bork Odin) – Magnus A Djuse (Anders Hafstad) – 1.24,0a</li>



<li>2020 <strong>Silver Jossan</strong> (e. Klack Jo) – Peter Eriksson (Simon Wall) – 1.24,0a</li>



<li>2023 <strong>Stjärnblomster</strong> (e. B.W.Modde) – Magnus A Djuse (Jan-Olov Persson) – 1.24,0a</li>



<li>2018 <strong>Mofaksan</strong> (e. Fakse) – Mikael Olsson – 1.24,2a</li>



<li>2021 <strong>Stjärnblomster</strong> (e. B.W.Modde) – Mats E Djuse (Jan-Olov Persson) – 1.24,2a</li>



<li>2022 <strong>Stjärnblomster</strong> (e. B.W.Modde) – Örjan Kihlström (Jan-Olov Persson) – 1.24,5a</li>



<li>2010 <strong>Vessle Jahna</strong> (e. Troll Jahn) – Harald Sandström (Märet Rusk) – 1.24,6a</li>



<li>2015 <strong>Hulte Nova</strong> (e. Järvsöviking) – Torbjörn Jansson (Leif Jonsson) – 1.24,7a</li>
</ul>



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



<p class="has-drop-cap">3Det kan bli en hel del Mats E Djuse i Bollnäs V75-omgång – om Sulkysports tipster har rätt i sina analyser. Förra veckan spikade Fredrik Persson på Simsalabim åttaoddsaren <strong>Eolo Wise L.</strong> och nu ställer han sitt hopp till Jörgen Westholm-tränade <strong>Castor The Star</strong> (e. Maharajah) i gulddivisionen, trots bakspår över sprinterdistans tillsammans med Mats E Djuse.</p>



<p>– Han gick jättebra i Sundsvall och är snabb även bakom hästar. Jag hoppas vi kan ha lite tur från start och kan komma igenom till en bra position. Han vinner ofta från ledningen, men har utvecklats och går bättre bakifrån nu än tidigare i karriären. Plan A är att testa lite framåt, men kommer Mozai till ledningen tror jag att han har bättre segerchans, sade Mats E Djuse till V65 Direkt.</p>



<p><a href="https://sulkysport.se/spelstugan/v75-tips-mindre-betrodd-an-jag-trott/" target="_blank" rel="noreferrer noopener">––> Här är hela tipsgenomgången till V75 i Bollnäs.</a></p>



<p><em>Vill du spela V75 tillsammans med Sulkysport och Simsalabim?</em><br><a href="https://www.atg.se/simsalabim/spel/296591_V75_2025-09-13_12_5" target="_blank" rel="noreferrer noopener">Systemförslaget går att köpa som andel för 153 kr/st här.</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/06/liliumsisumfm250619adamstromstaltzl-617x407.jpg" alt="" class="wp-image-733825"/><figcaption class="wp-element-caption">Petri Salmela-tränade Lilium Sisu och Mika Forss vann Breeders Crown-försök på Dannero. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">4Förra året blev det storslam för de svenska tränarna i Stokriteriet på Bjerke. Petri Salmelas <strong>Lilium Sisu</strong> (e. Face Time Bourbon) och Jan-Olov Perssons <strong>Hertiginnan Stöen</strong> (e. Tekno Odin) tog hem varsin klassisk titel. När Bjerke drar igång klasselöpshelgen idag är det stona i centrum med fyra stora finaler och nämnda duon finns med i varsin.</p>



<p>Lilium Sisu kvalade även in till Breeders Crown-finalen i Eskilstuna förra året, där hon dock galopperade. I år har hon matchats mot Stoderbyt, men även säkrat plats i BC-semifinalerna i årets upplaga efter att ha tagit enda årssegern i Breeders-försöket på Dannero i juni.</p>



<p>Hertiginnan Stöen har galopperat sex av tio starter i år och tagit sin enda årsseger i ett försök till Sleipner Cup i maj. Hon kvalade även in till Derbystoet i Östersund, men gjorde bort sig i finalen. Persson har även kvalat in <strong>Eld Prinsessa</strong> (e. Tekno Odin), som slutade femma i Derbystoet.<br>Det största svenska hoppet kanske är Skellefteåtränaren Jerker Bjurmans <strong>M.P.Flora</strong> (e. Tekno Odin), som tog andraplatsen bakom <strong>Hå Lerke</strong> (e. Nordsjö Odin) i Östersund – som 143-oddsare!</p>



<p>På norsk mark har Jan-Olov Persson tränat fem vinnare av Stokriteriet – Eldsiri, Uggla I Mossen, Dunungen, Majblomster och ifjol Hertiginnan Stöen – och har dubbla triumfer i Stoderbyt genom Eldsiri respektive Uggla I Mossen.<br>Persson saknar finalist bland de treåriga stona i år, där istället Bodentränaren Sandra Eriksson och Årjängamatören Rikard Häggström kvalat in varsitt sto.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/08/6halerke1-617x333.jpg" alt="" class="wp-image-753483"/><figcaption class="wp-element-caption">Hå Lerke och Öystein Tjomsland. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<h2 class="wp-block-heading">Svensktränade finalister – lördag</h2>



<p><strong>Stokriteriet, kallblod – förstapris 450.000 NOK:</strong></p>



<ul class="wp-block-list">
<li><strong>Tekla</strong> (e. Tekno Odin) – Sandra Eriksson</li>



<li><strong>Modiga Re</strong> (e. Ängsborken) – Magnus Teien Gundersen (Rikard Häggström)</li>
</ul>



<p><strong>Stoderbyt, kallblod – förstapris 700.000 NOK:</strong></p>



<ul class="wp-block-list">
<li><strong>Hå Lerke</strong> (e. Nordsjö Odin) – Öystein Tjomsland</li>



<li><strong>Hertiginnan Stöen</strong> (e. Tekno Odin) – Svein Ove Wassberg (Jan-Olov Persson)</li>



<li><strong>M.P.Flora</strong> (e. Tekno Odin) – Dag-Sveinung Dalen (Jerker Bjurman)</li>



<li><strong>Eld Prinsessa</strong> (e. Tekno Odin) – Tom Erik Solberg (Jan-Olov Persson)</li>
</ul>



<p><strong>Stoderbyt, varmblod – förstapris 850.000 NOK:</strong></p>



<ul class="wp-block-list">
<li><strong>Lilium Sisu</strong> (e. Face Time Bourbon) – Mika Forss (Petri Salmela)</li>
</ul>



<p>Förra året vann norske <strong>Frivoll Gorm</strong> (e. Ängsborken) Derbyt i både Sverige och Norge i Öystein Tjomslands regi. I början av sommaren flyttades hästen till Jörgen Westholms stall, där han tagit en andraplats på två försök. Idag startar valacken i DNT:s femåringslopp med 150.000 kronor till vinnaren. Tom Erik Solberg hoppar upp i vagnen – precis som vid fjolårets klassiska triumfer.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/09/13bj.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar på Bjerke.</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/08/00279259018scoopdyga-617x411.jpg" alt="" class="wp-image-761606"/><figcaption class="wp-element-caption">Keep Going och Mathieu Mottier tar hem Prix Jockey. Foto: Scoopdyga</figcaption></figure>



<p class="has-drop-cap">5Även i Frankrike är det klassiska titlar i potten när det tävlas om 14,5 miljon kronor (!) på kolstybben i eftermiddag. I centrum står Grupp I-löpningarna Criterium des 3, 4 och 5 ans med 135.000 euro i förstapris i samtliga lopp. </p>



<p>Många stjärnor selas ut och däribland familjen Bazires toppstammade <strong>Liza Josselyn</strong> (e. Ready Cash) och det fyraåriga stoet jagar fjärde raka segern i Criterium des 4 ans.<br>I Criterium des 5 ans startar <strong>Keep Going</strong> (e. Follow You) och han kommer till loppet med två semi-classique-triumfer i bagaget.<br>I Criterium des 3 ans är <strong>Mack de Blary</strong> (e. Face Time Bourbon) ut efter tredje raka vinsten efter ha vunnit Prix de Berlin (€90.000) och Yearling Cup/Arqana Trot (€150.000).</p>



<p>För svensk del då? Ja, det blir blågula inslag i samtliga fyra lopp som är öppna för europeiska hästar. Störst av dessa är Prix de Moulins la Marche (€75.000) med 33.750 euro till vinnaren över 2.850 meter. Sabine Kagebrants <strong>Iznogoud Am</strong> (e. Muscle Hill) ställs mot Johan Untersteiners tysk <strong>Toto Barosso</strong> (e. Ready Cash).</p>



<p>Övriga svenskfödda hästar på Vincennes är Jörgen Westholms <strong>Made of Stars</strong> (e. Super Ohoto Kosmos) i ett montélopp med 26.550 i förstapris, Conrad Lugauer reser till Paris för att köra <strong>Flying Drumsticks</strong> (e. Muscle Hill) i ett stolopp där vinnaren tar 27.000 euro, medan tysktränade <strong>Sangria Pellini</strong> (e. Chocolatier) tävlar om förstapriset 26.550 euro i ett annat stolopp.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2025-09-13/" target="_blank" rel="noreferrer noopener">Här är startlistorna till Vincennes tävlingar idag.</a></p>



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



<p class="has-drop-cap">6Sex gånger tidigare har numera Rommetränaren Katja Melkko haft häst till start i finskt Travkriterium. I eftermiddag plockar hon ut sin sjunde finalist när <strong>Odin Web</strong> (e. Like A Prayer) är en av tolv hästar bakom bilen i kamp om förstapriset på 80.000 euro i Tammerfors.</p>



<p>Odin Web har vunnit två av sex starter och slutade tvåa i Kriteriekvalet. Han har en del att leva upp till på tävlingsbanan – storebror är nämligen storstjärnan <strong>Elian Web </strong>(e. Like A Prayer), 1.09,9ak/€913.699. Denne blev förvisso ”bara” tvåa i Kriteriet, men vann istället finska Derbyt, Suur-Hollola-Ajo och Paralympiatravet.</p>



<p>Snabbast av försöksvinnarna var <strong>Magnitude</strong> (e. Maharajah). Modern <strong>Mascate Match</strong> (e. Muscle Mass), 1.10,0ak*/7.359.172 kr, hade en fantastisk karriär hos Pekka Korpi och Magnitude är hennes första avkomma. Mascate Match startade 32 gånger och vann 28 lopp!</p>



<p><strong>Startlista Finskt Travkriterium</strong><br>2.600 meter autostart, förstapris 80.000 euro.<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li><strong>El Narnia</strong> (e. E L Titan) – Iikka Nurmonen (Hannu-Pekka Korpi)</li>



<li><strong>Ancio</strong> (e. Nuncio) – Santtu Raitala (Markku Nieminen)</li>



<li><strong>Magnitude</strong> (e. Maharajah) – Hannu Torvinen (Hannu-Pekka Korpi)</li>



<li><strong>Arctic Fiona</strong> (e. Maharajah) – Janne Korpi (Juho Ihamuotila)</li>



<li><strong>Fuego Combo</strong> (e. Express Duo – Pekka Korpi</li>



<li><strong>Expanse’s Beauty</strong> (e. The Bosses Lindy) – Esa Holopainen (Kari Lehtonen)</li>



<li><strong>Odin Web</strong> (e. Like A Prayer) – Olli Koivunen (Katja Melkko)</li>



<li><strong>Shackhills Gambler</strong> (e. Jontte Boy) – Tuukka Varis (Jari Kinnunen)</li>



<li><strong>Piccolo Cocktail</strong> (e. Maharajah) – Jarmo Saarela (Timo Korvenheimo)</li>



<li><strong>Elvis Garden</strong> (e. Maharajah) – Jukka Torvinen (Tapio Mäki-Tulokas)</li>



<li><strong>Brutal Match</strong> (e. Brad de Veluwe) – Tuomas Korvenoja</li>



<li><strong>Legacy Luca</strong> (e. Muscle Mass) – Ari Moilanen (Markku Nieminen)</li>
</ol>



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



<p class="has-drop-cap">7Ikväll sätts punkt för säsongen på Ålandstravet utanför Mariehamn (första start 19.30) med sex lopp på menyn. Dessa har satts samman till en V65-kupong och den kryddas med nästan 600.000 jackpotkronor extra i sexrättspotten.</p>



<p>Tyvärr är det små fält på Åland med totalt 35 hästar anmälda till de sex loppen. Av dessa är 17 tränade i Sverige och den mest långväga gästen är Axevallatränaren Katarina Aurell Laursen, som sänder duon <strong>Kevin Jaam</strong> (e. Infinitif) och <strong>Ain’t Gonna Lose </strong>(e. Broadway Hall) med dottern Saga i sadel och sulky.</p>



<p>På svensk mark blir det breddlopp i Åmål (start 11.10) som inledning på lördagen. </p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/09/250913.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens tävlingar.</a></p>
