
<p class="has-drop-cap wp-block-paragraph">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 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.<br>2022 var ”International Trot” tillbaka och slutade med seger för norskfödde Cokstile (e. Quite Easy) och ifjol dominerade Alessandro Gocciadoro-tränade <strong>Vivid Wise As</strong> (e. Yankee Glide) och Matthieu Abrivard på 1.11,2a/2.011 meter. <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.</p>



<p class="wp-block-paragraph">Mats Djuse hade helst kunnat klona sig flera gånger om denna lördag. Han hade haft storloppschanser på tre banor i lika många länder och valde att resa över Atlanten för att köra <strong>Castro The Star</strong> (e. Maharajah) i VM-loppet.<br>– Det är ett enormt äventyr och jag kanske aldrig mer får chansen att köra VM-loppet, så i slutändan blev det ett ganska självklart val. Att det dessutom blir premiär för mig att köra i USA var ju också kittlande. De andra storloppen har jag redan kört och förhoppningsvis kommer det fler chanser i framtiden, säger Mats.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/djuse-smider-segerplaner-da-blir-det-fest/" target="_blank" rel="noreferrer noopener">Läs hela intervjun med Mats här!</a></p>



<p class="wp-block-paragraph">Det är en hel del svenskanknytningar bland de tio deltagarna på Yonkers. Tre av hästarna är svenskfödda (Castor The Star, Jiggy Jog och Hail Mary). Fem av hästarna är svensktränade (Castor The Star, Jiggy Jog, Hail Mary, Get A Wish och Periculum). Fyra av hästarna är svenskkörda (Idéal San Léandro, Castor The Star, Hail Mary och Get A Wish).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2019/11/hismajestysmcl950819-617x411.jpg" alt="" class="wp-image-55876"/><figcaption class="wp-element-caption">Catarina Lundström och Stefan Melander efter His Majestys seger i VM-loppet 1995. His Majesty är den senaste svenskfödde vinanren. Foto Stalltz.se</figcaption></figure>



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



<p class="wp-block-paragraph"><em>År – Namn – Körsven/tränare – Bana</em></p>



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



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



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



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



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



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



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



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



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



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



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



<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/06/stjarnblomster-617x333.jpg" alt="" class="wp-image-310394"/><figcaption class="wp-element-caption">Stjärnblomster och Mats E Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Svenskt Mästerskap för kallblodsston med 300.000 kronor till vinnaren och en gigantisk favorit i Jan-Olov Persson-tränade <strong>Stjärnblomster</strong> (e. B.W.Modde) som vunnit loppet tre år i rad. Per Linderoth ska lotsa henne till en fjärde titel i karriärens sista start. Stjärnblomster är nämligen dräktig med Bäcklös Uriel.</p>



<p class="wp-block-paragraph">Fast hennes skötare sedan hästen gjorde comeback efter att ha fått föl finns inte vid hennes sida i eftermiddag.<br>– Jag blev känslosam senast när hon vann på Bergsåker tillsammans med Mats, så därför känns det skönt att vara i Norge den här gången. Det hade blivit för jobbigt med allt ståhej runt omkring henne, säger Jenny Pettersson som istället är på Bjerke ned tre starthästar i Stoderbyt och Stokriteriet.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/fokus/jenny-aker-till-norge-hade-blivit-for-jobbigt/" target="_blank" rel="noreferrer noopener">––> Möt Jenny Pettersson i fredagsintervjun här!</a></p>



<p class="wp-block-paragraph">Stjärnblomster är V75-omgångens bästa enkelstreck och Sulkysports expert har grävt noga för att leta fram överraskningarna i en omgång som ser favoritbetonad ut på förhand.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v75-tips-stjarnblomster-avslutar-med-seger/" target="_blank" rel="noreferrer noopener">––> Här är hela tipsgenomgången till Hagmyrens V75-omgång i eftermidag.</a></p>



<p class="wp-block-paragraph">Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2024-09-07_17_5">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2024-09-07_17_5">Sulkysport V75 UNIK – 15 andelar á 150 kr/styck</a></p>



<p class="wp-block-paragraph">Lördagskvällen på svensk mark avslutas på Axevalla (start 18.30).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/09/240907.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/2023/08/janolovpersson3-617x333.jpg" alt="" class="wp-image-478962"/><figcaption class="wp-element-caption">Jan-Olov Persson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3På norsk mark har Jan-Olov Persson tränat fyra vinnare av Stokriteriet – Eldsiri, Uggla I Mossen, Dunungen och ifjol Majblomster – och har dubbla triumfer i Stoderbyt genom Eldsiri respektive Uggla I Mossen. I eftermiddag kan han öka antalet med finalister i båda finalerna i år.</p>



<p class="wp-block-paragraph"><strong>Majblomster</strong> (e. Tekno Odin) kommer till start i Stoderbyt med elva raka segrar och segrar i alla (!) storlopp. Ifjol vann hon Kriteriestoet, Stokriteriet och Oaks. I år finns Derbystoet och Sleipner Cup på meritlistan. Elva raka segrar kan bli tolv om hon lägger ytterligare en klassisk triumf under sina vingar. Treåriga <strong>Hertiginnan Stöen</strong> (e. Tekno Odin) överraskade alla – utom tränaren Jan-Olov Persson – när hon vann Kriteriestoet på Dannero som 44-oddsare.</p>



<p class="wp-block-paragraph">Nu jagar duon varsin stor titel på Bjerke och det sker med en vikarie i sulkyn. Sveriges allsvenske kuskchampion de två senaste säsongerna, Magnus A Djuse, ersätter storebror Mats E Djuse bakom Perssons duo.</p>



<h2 class="wp-block-heading">Svensktränade hästar i de klassiska finalerna</h2>



<ul class="wp-block-list">
<li><strong>Kallblod, stokriteriet (450.000 kr):</strong> Hertiginnan Stöen (Magnus A Djuse/Jan-Olov Persson). </li>



<li><strong><strong>Kallblod, s</strong>toderbyt (700.000 kr):</strong> Majblomster (Magnus A Djuse/Jan-Olov Persson), Ängspuma (Robert Skoglund), Nytomt Amira (Roy Atle Ruud Nilsen/Håkan Halvardsson), Järvsö Britt (Ole Johan Östre/Jan-Olov Persson).</li>



<li><strong>Varmblod, stokriteriet (650.000 kr): </strong>Lilium Sisu (Mika Forss/Petri Salmela).</li>
</ul>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/09/2024bjerkeklasselopshelg.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Bjerkes storloppstävlingar lördag-söndag.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4I skuggan av VM-loppet på Yonkers Raceway ikväll svensk tid så hålls fyra finaler i New York Sire Stakes ($225.000) för två- och treåringar. <br>Följande svensktränade hästar startar:</p>



<p class="wp-block-paragraph"><strong>Tvååriga hingstar/valacker:</strong><br>Super Chapter (e. Chapter Seven) – Dexter Dunn/Marcus Melander<br>Civilian Drone (e. Chapter Seven) – Yannick Gingras/Nancy Takter<br>Variegated (e. Chapter Seven) – Braxten Boyd/Marcus Melander<br>Happy Jack B (e. Chapter Seven) – Tyler Buter/Åke Svanstedt<br>Gangsta Talk (e. Chapter Seven) – Åke Svanstedt<br>Moonshot (e. Chapter Seven) – Scott Zeron/Marcus Melander</p>



<p class="wp-block-paragraph"><strong>Tvååriga ston:</strong><br>Morning Angel (e. Chapter Seven) – Björn Goop/Marcus Melander<br>Beautiful Sight (e. Chapter Seven) – Tyler Buter/Åke Svanstedt<br>Royal Mission (e. Chapter Seven) – Scott Zeron/Marcus Melander</p>



<p class="wp-block-paragraph"><strong>Treåriga hingstar/valacker: </strong><br>Nottingham (e. E L Titan) – David Miller/Jenny Melande<br>Mister Mellby (e. Chapter Seven) – Åke Svanstedt<br>Thinker Monkey (e. Chapter Seven) – Scott Zeron/Marcus Melander<br>Wild Ticket (e. Chapter Seven) – Dexter Dunn/Marcus Melander</p>



<p class="wp-block-paragraph"><strong>Treåriga ston: </strong><br>Senorita Palema (e. Chapter Seven) – Åke Svanstedt</p>



<p class="wp-block-paragraph">Ett lopp för äldre travare – Bob Miecuna Invitational ($250.000) – hålls också och där startar Per Engblom <strong>Tipsy Moni</strong> (e. International Moni), Marcus Melander <strong>Venerate</strong> (e. Love You) och Åke Svanstedt <strong>Cecil Hanover</strong> (e. Chapter Seven). </p>



<p class="wp-block-paragraph"><a href="https://racing.ustrotting.com/goto.aspx?target=12,96675" target="_blank" rel="noreferrer noopener">Här hittar du samtliga startlistor till Yonkers Raceways tävlingar och där första loppet släpps iväg klockan 18.00. </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/2022/06/fromthemine-617x333.jpg" alt="" class="wp-image-318855"/><figcaption class="wp-element-caption">Catarina Norqvist-tränade From The Mine. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5I finska Uleåborg startar två svensktränade hästar i gulddivisionsfinalen med 10.000 euro i förstapris. Det handlar om Petri Salmelas <strong>Leave Your Sox On</strong> (e. Trixton) och Catarina Norqvists <strong>From The Mine</strong> (e. From Above).</p>



<p class="wp-block-paragraph">Den svenskfödda duon var etta och tvåa i högsta klassen i Torneå för en dryg månad sedan med Leave Your Sox On. Denne vann också spårlottningen, då han drog bricka två bakom bilen med Iikka Nurmonen i sulkyn, medan From The Mine handikappas av spår elva tillsammans med Tuukka Varis.</p>



<p class="wp-block-paragraph">Bland motståndarna finns forne Elitloppstrean <strong>Gareth Boko</strong> (e. Make It Happen), Pekka Korpis topphäst <strong>Run For Royalty</strong> (e. R.C.Royalty) och svenskfödde 1.08,3-travaren <strong>Hierro Boko</strong> (e. From Above).</p>



<p class="wp-block-paragraph"><strong>Startlista, gulddivisionsfinal Uleåborg</strong><br><em>2.120 meter autostart</em>:</p>



<ol class="wp-block-list">
<li>American Hero – Tommi Kylliäinen (Henry Bollström)</li>



<li>Leave Your Sox On – Iikka Nurmonen (Petri Salmela)</li>



<li>Epimetheus – Niko Jokela (Antti Ala-Rantala)</li>



<li>Kyle Web – Henrik Bollström (Timo Korvenheimo)</li>



<li>Main Stage – Santtu Raitala (Antti Ojanperä)</li>



<li>Run For Royalty – Pekka Korpi</li>



<li>Gareth Boko – Esa Holopainen (Risto Kuusisto)</li>



<li>Dozen of Oysters – Jukka Torvinen (Antti Ojanperä)</li>



<li>Hierro Boko – Jarmo Saarela (Risto Kuusisto)</li>



<li>Farzad Boko – Antti Ala-Rantala</li>



<li>From The Mine – Tuukka Varis (Catarina Norqvist)</li>



<li>Jason’s Camden – Hannu Torvinen (Christa Packalén)</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">6Ett digert utbud väntar på kvällens auktion hos Travera. Hela 34 hästar och två betäckningsrätter finns i den digitala auktionskatalogen när första utrop är klockan 19.15 ikväll.</p>



<p class="wp-block-paragraph">Bland hästarna som säljs kan noteras:<br>Fyraårige <strong>Zebulon</strong> (e. Quite Easy), 1.12,4am/389.400 kr, som vunnit sex av 19 starter.<br>Ett av åtta fölston är Derbystovinnaren <strong>Red Red Red </strong>(e. Offshore Dream), 1.11,3am*/1.950.062 kr.<br>Tvååringar med fäder som <strong>Bird Parker, Donato Hanover</strong> och <strong>S.J.’s Caviar.</strong></p>



<p class="wp-block-paragraph"><a href="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här går det att se hästarna som säljs och följa budgivningen under kvällen.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">7Under 99 år tävlades det på hippodromen i Tallinn, men sedan några år tillbaka är tävlingsplatsen Tuula, 29 kilometer från Tallinn, mellan Keila och Ääsmäe. Där och idag ska Jevgeni Ivanov försöka ta sin tolfte seger i det estländska Kriteriet (€8.800) för treåringar. </p>



<p class="wp-block-paragraph">Två treåringar har Ivanov till sitt förfogande – <strong>Rebeka Tooma</strong> och <strong>Rambo Tooma</strong> – och han väljer själv att köra den sistnämnde, medan Jelena Fironova tar hand om Rebeka Tooma. </p>



<p class="wp-block-paragraph"><strong>Estländskt Kriterium (€8.800), treåringar</strong><br>2.640 meter autostart, förstapris: 4.000 euro.</p>



<ol class="wp-block-list">
<li>BWT Joalin (e. Appomattox) – Aimur Mets</li>



<li>Rescator (e. So Perfect) – Mahmoud Abdalla</li>



<li>Rebeka Tooma (e. Broadway Hall) – Jelena Fironova</li>



<li>Baciami (e. Mosaique Face) – Svetlana Jegorova</li>



<li>Stoneisle Wilbur (e. Jontte Boy) – Vilis Tsizevski</li>



<li>Moderna (e. Pronto Rib) – Egidijus Gudonis</li>



<li>Rambo Tooma (e. Donato Hanover) – Jevgeni Ivanov</li>



<li>Mon’s Isfumarol (e. Tobin Kronos) – Natalia Borisenko</li>
</ol>

Fokustema
Morgonsvepet
Läs senare
29 års väntan på VM-guld
Alla svenskar som vunnit VM-loppet. Avslutar karriären med SM-guld? Perssons dubbla chanser till nya klassiker. Svensktätt i miljonlopp. Blågula hopp i guldsivisionsfinal – i Finland. Solvallatränare jagar ny Kriterieseger.
Detta och mer i lördagens ”Sju nyheter vid sju”.
Detta och mer i lördagens ”Sju nyheter vid sju”.
