
<p class="has-drop-cap wp-block-paragraph">1Den ena kommer från andraplatsen i VM-loppet på Yonkers Raceway i USA. Den andre vann Svensk Mästerskap i överlägsen stil på Åby efter en rykande avslutning. Så gick det i de senaste starterna för favoritduon i C.L. Müllers Memorial på Jägersro (första start 13.30) idag.</p>



<p class="wp-block-paragraph">När <strong>Diva Ek</strong> (e. Trixton) och <strong>A Fair Day</strong> (e. Maharajah) möts i årets upplaga av landets äldsta storlopp för äldre hästar kanske spårlottningen avgjorde till italienskan Diva Eks fördel. Alessandro Gocciadoros sto drog spår tre bakom bilen, medan Elisabeth Almshedens A Fair Day inleder från bricka tolv i långloppet.</p>



<p class="wp-block-paragraph">Diva Ek gör första starten sedan raketspurten till andraplatsen i VM-loppet.<br>– Diva Ek gick otroligt bra i USA. Hon tog resan väldigt bra, verkar pigg och glad. Förra året gick hon till Wolvega och vann direkt på ett mycket bra vis och ingenting tyder på att hon ska vara sämre i år utan tvärtom är hon minst lika bra. Hon har vunnit på Vincennes över lång distans så det är inget som oroar mig alls. Detta blir förmodligen sista starten i Sverige i år innan vi siktar mot det franska vintermeetinget. Inga ändringar, säger Alessandro Gocciadoro på sin blogg.</p>



<p class="wp-block-paragraph">A Fair Day då?<br>– A Fair Day var grym när han vann SM på Åby. Nu är det ett nytt lopp och jag måste säga att det känns väldigt jobbigt från det här spåret. Som de flesta vet är det mycket svårt att vinna den här typen av lopp från spår tolv i Malmö. Det jag vet om framtiden är att tränaren vill starta i finalerna i Stockholm, säger kusken Oscar Ginman till Kanal75.</p>



<p class="wp-block-paragraph">Om spårlottningen gick i Diva Eks favör, så talar historien för A Fair Day. Två år i rad har Kalmars hjälte vunnit loppet som avgjordes första gången 1927! <br>400.000 kronor är förstapriset i årets upplaga av Müllers.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/10/24v85.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Jägersros V85-tävlingar idag.</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/10/chatroommadgk-617x333.jpg" alt="" class="wp-image-914697"/><figcaption class="wp-element-caption">Daniel Redén-tränade Chat Room och Magnus A Djuse. Foto Gunilla König/Stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Johan Jacobssons Minne har inte lika lång historia som Müllers, men loppets segerlista lyser av starka namn sedan första upplagan som avgjordes 1959.</p>



<p class="wp-block-paragraph">Johan Jacobsson vann själv femte upplagan av Svenskt Travkriterium 1931 med <strong>Blue Bird </strong>(e. Belgic). Sonen Curt skänkte en silverpjäs, värderad till flera hundra tusen kronor, som hederspris i loppet till minne av Nevitsborgs Travarstuteris grundare. För att ta hem pjäsen krävs att samma hästägare vinner loppet tre gånger, vilken ingen lyckats med hittills. Stall Traviata, Stall Gån, Stall Value Line, Ilkka Kemppi och Denco HB har vardera två inteckningar, skrivs i Jägersros program till dagens tävling.</p>



<p class="wp-block-paragraph">Treåringarna finns på startfållan, 2.140 meter, och fyraåringarna jagar 20 meter bakom från start i en alltid lika intressant drabbning.<br>Kanske är det dags för en första inteckning för Stall Zet. Daniel Redén sänder fyraårige kanadensaren <strong>Chat Room</strong> (e. Chapter Seven) söderut för att kuskas av Magnus A Djuse.<br>–  Chat Room är en helmysig häst och Magnus var också väldigt förtjust i honom när han körde till seger senast. Han stack undan snyggt över upploppet när tussarna drogs och det är en mycket spännande häst. Nu är det andra förutsättningar än vad han är van vid och fjärdespår i voltstart är förstås lurigt, men jag hoppas han reder ut det och då är det en häst som alltid ska räknas. Barfota runt om, säger Daniel Redén på sin hemsida reddis.se.</p>



<p class="wp-block-paragraph">Sulkysports expertpanel har synat omgången och en av experterna lyfter fram Chat Room som dagens bästa spik. Expertpanelen bjuder på sina bästa spikar och roliga skrällar i Jägersros omgång – <a href="https://sulkysport.se/spelstugan/v85-tips-j-24-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-24_7_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-24_7_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-24_7_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Spelpoolen.</a></p>



<p class="wp-block-paragraph">Det tävlas även på Romme (första start 11.10) idag och där står breddlopp på programmet.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/10/261024.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/2026/08/apexp22608009adamstromstalltz2-617x479.jpg" alt="" class="wp-image-884615"/><figcaption class="wp-element-caption">Apex med segertäcket från Hambletonian Stakes. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3Marcus Melanders treåringsstjärnor <strong>Apex</strong> (e. Walner) och <strong>Nezuko Kamado</strong> (e. Chapter Seven) gav den svenske stortränaren hans största tävlingsdag någonsin när duon vann Hambletonian Stakes respektive Hambletonian Oaks.<br>Inatt väntar säsongens sista stora uppgift för de båda mångmiljonärerna när nordamerikanska Breeders Crown-helgen fortsätter med finaler för både treåriga och äldre travare.</p>



<p class="wp-block-paragraph">Den blågula dominansen är stor på förhand. I finalen för treåriga hingstar och valacker är sex av tio finalister tränade av svenskar och lika stor är dominansen på stosidan, sex av nio. <br>Nezuko Kamado är svenskfödd och detsamma gäller en av hennes motståndare i BC-finalen för treåriga ston, Åke Svanstedts <strong>Busy Miss Lissy</strong> (e. Calgary Games). </p>



<p class="wp-block-paragraph"><strong>Breeders Crown ($664.500) – treåriga hingstar/valacker</strong><br>1.609 meter autostart.<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li><strong>American Power</strong> (e. Walner) – Yannick Gingras (Marcus Melander)</li>



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



<li><strong>Diabolic Hill</strong> (e. Muscle Hill) – Todd McCarthy</li>



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



<li><strong>Nix Nacken</strong> (e. Muscle Hill) – Ronnie Wrenn J:r (Marcus Melander)</li>



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



<li><strong>Strobe Lite</strong> (e. Alarm Detector) – Louis Roy</li>



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



<li><strong>Captain Jordan</strong> (e. Captain Corey) – Chris Page</li>
</ol>



<p class="wp-block-paragraph"><strong>Breeders Crown ($664.500) – treåriga ston</strong><br>1.609 meter autostart.<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li><strong>Storybook Love</strong> (e. Chapter Seven) – Todd Ratchford</li>



<li><strong>Victorianas Secret</strong> (e. Tactical Landing) – Ronnie Wrenn J:r</li>



<li><strong>She’s Moni</strong> (e. Walner) – Yannick Gingras (Nancy Takter)</li>



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



<li><strong>Little Road</strong> (e. Fordham Road) – Brandy Brown</li>



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



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



<li><strong>Southwind Chaska</strong> (e. Tactical Landing) – Todd McCarthy (Jim Oscarsson)</li>



<li><strong>Busy Miss Lissy</strong> (e. Calgary Games) – Åke Svanstedt (Åke Svanstedt)</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/08/superchapterddm260808adamstromstalltz-617x405.jpg" alt="" class="wp-image-883794"/><figcaption class="wp-element-caption">Utvändige Super Chapter plockar ner Lexus Kody i spurten. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4Heter Nordamerikas bästa äldre häst <strong>Super Chapter</strong> (e. Chapter Seven)? Mycket talar för det efter en strålande fyraåringssäsong hos Marcus Melander. Sju segrar och två andraplatser har det blivit i år för Super Chapter.</p>



<p class="wp-block-paragraph">Melanders häst vunnit Yonkers International Trot ($1.000.000), Maple Leaf Trot (C$620.000), John Cashman Memorial ($281.200), Dayton Trotting Derby ($250.000) och två försök i Graduate Series ($50.000) under 2026.<br>Förra året var Super Chapter den vinstrikaste treåringen i världen och noterade 1.08,4/1.609 meter när han vann Earl Beal Jr. Memorial ($300.000) och det var världsrekord för treåriga hingstar på tusenmetersbana. Han startade 14 gånger (9-3-1) och tjänade 1.236.099 dollar.</p>



<p class="wp-block-paragraph">Super Chapter kan kröna segern med vinst i Breeders Crown-finalen, där han bland annat ställs mot världens snabbaste travare på milebana, <strong>On To Norway</strong> (e. Muscle Massive), och svenskfödde <strong>Antognoni</strong> (e. Father Patrick), vilka båda tränas av Ron Burke.<br>Melander valde att stå över försöket med Super Chapter som var direktkvalificerad till finalen, men detta på bekostnad på utgångsläget. En framgång i försöket hade garanterat spår ett till sex bakom bilen i finalen. Nu tvingas Super Chapter inleda från bricka åtta.</p>



<p class="wp-block-paragraph">En svenskfödd travade är också med i stonas Breeders Crown-final i Petter Engblom-tränade <strong>Bravo Angel</strong> (e. Readly Express). Fyra av nio hästar i finalen tränas av svenskar.</p>



<p class="wp-block-paragraph"><strong>Breeders Crown ($600.000) – äldre hästar</strong><br>1.609 meter autostart.<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>French Wine (e. Bar Hopping) – Jason Bartlett (Nancy Takter)</li>



<li>Gimpanzee Dancer (e. Gimpanzee) – David Miller</li>



<li>Lexus Kody (e. Archangel) – Tim Tetrick</li>



<li>Emoticon Legacy (e. Walner) – Bob McClure</li>



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



<li>Go Dog Go (e. Greenshoe) – Scott Zeron</li>



<li>On To Norway (e. Muscle Massive) – Ronnie Wrenn J:r</li>



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



<li>Up Your Deo (e. Walner) – Åke Svanstedt (Åke Svanstedt)</li>
</ol>



<p class="wp-block-paragraph"><strong>Breeders Crown ($400.000) – äldre hästar ston</strong><br>1.609 meter autostart.<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li><strong>Tactical Moni</strong> (e. Tactical Landing) – Dexter Dunn (Marcus Melander)</li>



<li><strong>Jurassic Hattie</strong> (e. Volstead) – Brett Miller</li>



<li><strong>Miracle Maven</strong> (e. Don’t Let-Em) – Ronnie Wrenn J:r</li>



<li><strong>Bravo Angel</strong> (e. Readly Express) – Jason Bartlett (Petter Engblom)</li>



<li><strong>R Dutchess</strong> (e. Father Patrick) – Tim Tetrick</li>



<li><strong>Warrawee Michelle</strong> (e. Walner) – Åke Svanstedt (Åke Svanstedt)</li>



<li><strong>Woman of Passion</strong> (e. Walner) – Andrew McCarthy</li>



<li><strong>Delaney Hanover</strong> (e. Muscle Hill) – Scott Zeron (Lucas Wallin)</li>



<li><strong>Walspea</strong> (e. Walner) – Yannick Gingras</li>



<li><strong>Yo Tillie</strong> (e. Tactical Landing) – Todd McCarthy</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/07/kingslayer-617x411.jpg" alt="" class="wp-image-872376"/><figcaption class="wp-element-caption">Kingslayer Pellini vid en tidigare seger i år. Foto: Scoopdyga</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5Svenskfödde <strong>Kingslayer Pellini</strong> (e. Up And Quick) tävlar om stora pengar i Grand Prix Salon de Provance (€64.000) idag där 28.800 euro väntar vinnaren i trekilometersloppet.<br>Vincent Martens-tränade Kingslayer Pellini är belastad med 25 meters tillägg och körs av Theo Briand när han jagar tredje raka segern. Kingslayer Pellini – lillebror till Readly Express – har haft ett strålande 2026 på fransk mark och vunnit åtta av tio starter!</p>



<p class="wp-block-paragraph">En svensk tränare har häst till start, nämligen Conrad Lugauer som plockar ut <strong>Dareios di Poggio </strong>(e. Father Patrick) i Grand Prix de la Ville de Grenade-sur-Garonne (€21.000). Hästen startar från 25 meters tillägg med Etienne Clozier i vagnen.<br>För Dareios di Poggio blir det femte starten på fransk mark och han har en seger, på gräsbanan Royan-Atlantique i augusti.</p>



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



<p class="has-drop-cap wp-block-paragraph">6Tio starter, tio segrar och en stil som gjort stora avtryck i travsporten. Treåriga norska stoet <strong>Express Go</strong> (e. Readly Express) har charmat travpubliken under debutsäsongen med sin låga huvudföring, höga kapacitet och segervilja.<br>Amatörtränaren Ola Standahls segermaskin har vunnit norska Stokriteriet, Biris Elitlopp, Hans Petter Tholfsens Minneslopp och Tamin Sandys Äreslopp hittills i år, men missade Oaks på Momarken nyligen då hon inte var anmäld.</p>



<p class="wp-block-paragraph">Idag görs den långa turen till Sörlandet för start i DNT:s höstfinal för treåringar mned 100.000 norska kronor i förstapris och Dag-Sveinung Dalen håller i tömmarna. Där ställs hon mot Kriterievinnaren <strong>Pele B.R.</strong> (e. Calgary Games), som tränas av Frode Hamre.</p>



<p class="wp-block-paragraph">Sex hästar startar i varmblodsklassen, medan kallblodens höstfinal lockat sju. En av dem är svenskfödd och svenskägd, Öystein Tjomsland-tränade <strong>Holger W.</strong> (e. Tangen Bork).</p>



<p class="wp-block-paragraph"><a href="https://www.travsport.no/travbaner/sorlandets-travpark/startlist/2026-10-24" target="_blank" rel="noreferrer noopener">Här är startlistorna till Sörlandets tävlingar ikväll.</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/2025/10/massimohoist-617x333.jpg" alt="" class="wp-image-782887"/><figcaption class="wp-element-caption">Massimo Hoist. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">7Hela 36.000 euro väntar vinnaren när finskt S:t Leger (€79.200) avgörs i Björneborg idag. Den prissumman har bland annat lockat Finlands bästa äldre häst <strong>Massimo Hoist</strong> (e. Muscle Hill), som var Elitloppsfinalist förra året.<br>I år tvingades hästen tacka nej till Solvallas storlopp efter svaga formbesked under senvåren, men han har haft en stark säsong ändå. Sju segrar på elva starter är resultatet.</p>



<p class="wp-block-paragraph">Just oktoberloppet S:t Leger är annars en riktig favorit för Massimo Hoist, sopm tagit hem loppet två år i rad. Förra året satte Jukka Hakkarainens travare nytt världsrekord när han segrade på 1.12,4/2.640 meter voltstart!</p>



<p class="wp-block-paragraph">16 hästar gör upp i årets upplaga, där Massimo Hoist och ytterligare åtta hästar inleder från 40 meters tillägg. Ston och fyraåringar har 20 meters gottgörelse och årets finske Derbytvåa <strong>Magnitude</strong> (e. Maharajah) startar 20 meter före Massimo Hoist och gänget.</p>



<p class="wp-block-paragraph">Finlands överlägsne kusketta Santtu Raitala är tillbaka på banan idag efter att ha avtjänat en månads avstängning efter en uppmärksammad härva med trakasserande telefonsamtal.</p>



<p class="wp-block-paragraph"><strong>Startlista S:t Leger (€79.200)</strong><br>2.600 meter voltstart<br><em>Häst – Kusk</em></p>



<ol class="wp-block-list">
<li>Lafayette – Tino Kebäänranta</li>



<li>El Narnia – Hannu-Pekka Korpi <br><strong>2.620 meter:</strong></li>



<li>Ginza – Tommi Kylliäinen</li>



<li>Magnitude – Ari Moilanen</li>



<li>True Colors – Elina Leinonen</li>



<li>Amanda Evo – Ville Koivisto</li>



<li>Callela Capitano – Jukka Torvinen <br><strong>2.640 meter:</strong></li>



<li>The Lost Battalion – Esa Holopainen</li>



<li>Massimo Hoist – Hannu Torvinen</li>



<li>Main Stage – Santtu Raitala</li>



<li>Odin Orden – Juha Utala</li>



<li>Edward Snipes – Ville Pohjola</li>



<li>Corazon Combo – Pekka Korpi</li>



<li>Amazing Player – Jarmo Saarela</li>



<li>Fly By Me – Harri Koivunen</li>



<li>Knight Rider Hoss – Olli Koivunen</li>
</ol>

Fokustema
Sju nyheter vid sju
Läs senare
Vinnaren i storloppsduellen
VM-tvåa eller SM-etta i Müllers? Melanders treåringsstjärnor i blågul BC-fest. Readly Express lillebror på nya fransk segerjakt. Norska snackhästen jagar elfte raka. Finlands kusketta tillbaka efter månadsavstängning.
Detta och mer i lördagens ”Sju nyheter vid sju”.
Detta och mer i lördagens ”Sju nyheter vid sju”.
