
<p class="has-drop-cap wp-block-paragraph">1Tvåa i STL-ligan för tränare och tio hästar till start på hemmabanan Bergsåker (start 15.20) – är det dags för Daniel Wäjersten att komma ikapp Johan Untersteiner som leder med tre segrar inför lördagens tävlingar? </p>



<p class="wp-block-paragraph">Han sitter i alla fall med starka kort på handen den gode Wäjersten och han är förhandsfavorit i två av åtta avdelningar på V85-kupongen. En av dessa är omgångens största favorit <strong>Shogun R.R.</strong> (e. Readly Express), som resan vunnit åtta av 14 starter under 2025. Nu väntar ett klass I-försök över lång distans och spår två bakom startbilen.<br>– Det har blivit lite långt mellan loppen, men jag har inte sökt lopp när han hade detta och dessutom har startat mycket i år. Optimalt skulle ha dock haft ett lopp för 14 dagar sedan, sade Daniel Wäjersten till V65 Direkt om sin fyraåring som vann i sin senaste start i slutet av september över 3.160 meter.</p>



<p class="wp-block-paragraph">Shogun R.R. har gjort sex starter över 2.640 meter eller längre distans och vunnit fyra av dessa, däribland två raka segrar över drygt tre kilometer.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/11/08v85.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens V85-tävlingar på Bergsåker.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">225 miljoner kronor extra i jackpotpengar – och totalt över 50 miljoner i åttarättspotten utlovas av ATG i eftermiddagens V85-omgång på Bergsåker (första start 15.20). Hjälp på traven i jakten på miljonerna? Några av landets främsta tippare ger sitt bästa spikförslag till omgången och bjuder dessutom på varsitt skrällbud.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v85-tips-experternas-jackpotdrag/" target="_blank" rel="noreferrer noopener">Här är experternas tips till V85 på Bergsåker.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela andelsspel i jackpotomgången finns möjligheten här:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/69ansspel/V85_2025-11-08_9_3" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos 69:ans Spel &#038; Tobak.</a><br><a href="https://www.atg.se/spelpoolen/V85_2025-11-08_9_3" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Spelpoolen.</a><br><a href="https://www.atg.se/simsalabim/V85_2025-11-08_9_3" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Simsalabim.</a></p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/11/ulvsasen1-617x333.jpg" alt="" class="wp-image-790844"/><figcaption class="wp-element-caption">Anders Wallin-tränade Ulvsåsen och Ulf Ohlsson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Gulddivisionen är placerad utanför det stora streckspelet idag, medan däremot absoluta topphästar dyker upp i dubbelcupsfinalen Brimsguttens Minne med dagens högsta förstapris: 200.000 kronor. Gunnar Melanders <strong>Månlykke A.M.</strong> (e. Månsprinsen A.M. har blivit svensk mästare fyra gånger, 20220, 2021, 2022 och 2024. Anders Wallins segermaskin <strong>Ulvsåsen</strong> (e. Åsajerven) vann SM i somras.</p>



<p class="wp-block-paragraph">Nu möts de båda stjärnhästarna för femte gången och den inbördes statistiken är helt jämn mellan de båda: 2-2.</p>



<p class="wp-block-paragraph">Anders Wallin håller segern i SM högt.<br>– Det var fantastiskt kul och för mig är det loppet det näst största man kan vinna under ett år.. Jag har sett Viggo Best, Sjunga Best, Järvsöfaks och Månprinsen A.M. så visst drömde jag om att få vinna SM en gång i livet. Man har inte så många chanser att vara med i sådana lopp, säger Anders i Sulkysports fredagsintervju.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/fokus/wallin-gav-upp-och-kom-igen/" target="_blank" rel="noreferrer noopener">Läs hela intervjun här om en karriär som tog fart för 40 år sedan – fast den egentligen inte skulle ha gjort det!</a></p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/06/manlykkea.m.2024-617x333.jpg" alt="" class="wp-image-599068"/><figcaption class="wp-element-caption">Gunnar Melander bakom stjärnan Månlykke A.M. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Gunnar Melander aviserar barfota runt om och norsk huvudlag för Månlykke A.M.<br>– Han visade sig jättefin barfota i två lopp i september och det kan även blir norskt huvudlag för första gången sedan Elitkampen, då han gick med halvstängt norskt. Ulvsåsen borde bli skyhög favorit men jag har en bra häst och med rätt löpning har han slagit de här hästarna förut. Jag åker till Bergsåker med inställningen att vi kan vinna, säger Gunnar Melander till Kanal75.</p>



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



<p class="has-drop-cap wp-block-paragraph">3Efter 20 tävlingsdagar är det dags att stänga för säsongen på Visbytravet (första start 11.10). Dominanten på banan är flitige Solvallagästen Claes Sjöström, som redan räknat hem sitt tionde raka kuskchampionat på banan och det 13:e totalt på Gotland.</p>



<p class="wp-block-paragraph">Men om Sjöström även blir tränarchampion på Skrubbs återstår att se. Dramatiken championmässigt finns nämligen när det gäller tränarligan.</p>



<p class="wp-block-paragraph">Sjöström står över säsongsavslutningen både som kusk och tränare och får hållatummarna att hans 16 segrar och åtta andraplatser räcker för att hålla undan även till tränarchampionatet. Bakom jagar nämligen hemmatränare Henrik Hoffman, som Sjöström kört en hel del åt under säsongen, på 14 segrar och 13 andraplatser. En dubbel för stallets sex startande hästar idag behövs för att passera Claes Sjöström i tränarligan.<br>Teoretiskt sätt är inte heller Jörgen S Eriksson (tre starthästar) och Thomas Jonsson (17 starthästar) borta från tränartiteln, men det krävs mycket för att utmana tätduon.</p>



<p class="wp-block-paragraph">Dagens största lopp är Visbytravets Treåringspris med 60.000 kronor till vinnaren, där Jörgen S Erikssons <strong>Timotejs Obelix</strong> (e. Maharajah) och Henrik Hoffmans <strong>Jack Grealish</strong> (e. Power) ser ut att göra upp om segern.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/11/08v4.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Visbys 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/2024/05/2divaek-617x333.jpg" alt="" class="wp-image-588114"/><figcaption class="wp-element-caption">Diva Ek med sin tränare Alessandro Gocciadoro. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4Anrika Prijs der Giganten (€66.000) avgörs på fredag på Victoria Park i nederländska Wolvega. En häst på svensk träningslista åker till Wolvega för att tävla när Alessandro Gocciadoro plockar ut italienskan <strong>Diva Ek</strong> (e. Trixton).<br>Det sexåriga stoet har inte startat sedan hon överraskade i VM-loppet på Yonkers Raceway för snart två månader sedan, där hon spurtade till andraplatsen bakom kanadensiske vinnare <strong>Lexus Kody </strong>(e. Archangel). Diva Ek fördubblade sin prissumma genom andraplatsen i New York.</p>



<p class="wp-block-paragraph">Förra året vanns Prijs der Giganten av Philippe Allaires Elitloppsvinnare Hohneck (e. Royal Dream) tillsammans med Gabriele Gelormini. </p>



<p class="wp-block-paragraph"><strong>Startlista Prijs der Giganten (€66.000)</strong><br>2.100 meter autostart, fredag 14 november<br><em>Häst (far) – Tränare</em></p>



<ol class="wp-block-list">
<li><strong>Heart of Steel</strong> (e. Cantab Hall) – Alessandro Gocciadoro</li>



<li><strong>Gala de Crennes</strong> (e. Opus Viervil) – Erno Szirmay</li>



<li><strong>Hades de Vandel</strong> (e. Ganymede) – Paul Hagoort</li>



<li><strong>Elvis du Vallon</strong> (e. Reve de Beylev) – Charles Cuiller</li>



<li><strong>Ideal San Leandro</strong> (e. Timoko) – Richard Westerink</li>



<li><strong>Kevin Prince</strong> (e. Follow You) – Michel Rothengatter</li>



<li><strong>Hidalgo des Noes</strong> (e. Opium) – Stephane Provoost</li>



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



<li><strong>Niagara River</strong> (e. Orlando Vici) – Danny Brouwer</li>



<li><strong>Knockonwood</strong> (e. Ready Cash) – Romain Christian Larue</li>



<li><strong>Jimmy Ferro BR</strong> (e. Love You) – Wolfgang Nimczyk</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">5Svenska hästar och tränare lyser med sin frånvaro på Vincennes i eftermiddag, där största loppet är grupp III-klassade Prix du Languedoc (€90.000) över 2.850 meter.</p>



<p class="wp-block-paragraph">Loppet har genom åren sett svenskfödda vinnare som <strong>Com Early</strong> (e. Pythagoras), <strong>Ilo Håleryd</strong> (e. Napoletano), <strong>Moving On</strong> (e. Quite Easy), <strong>Cash Gamble</strong> (e. Ready Cash) och för fem år sedan Fredrik B Larssons <strong>Milliondollarrhyme</strong> (e. Ready Cash), men i år möts tio franska och två italienska travare i loppet, där Erik Bondo-tränade <strong>Cobra Killer Bar</strong> (e. Realdy Express) jagar sjätte raka segern på fransk mark.</p>



<p class="wp-block-paragraph">Däremot blir det blågula inslag på kvällsbanan Le Croise-Laroche, där Chrstoffer Eriksson plockar ut franske <strong>Jupiter Delo</strong> (e. Ready Cash) i ett lopp över 2.700 meter med bilstart. Förstapriset är 9.450 euro. Hästen gör andra starten i Christoffers regi och blev diskvalificerad i regidebuten i juli.</p>



<p class="wp-block-paragraph">Svenskan Marie Norberg sitter i vagnen från bakspår och Marie startar även egna hästen <strong>Lady d’Elfe</strong> (e. Bon Copain) i ett annat lopp med samma förutsättningar vad gäller distans, startmetod, utgångsläge och förstapris. </p>



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



<p class="has-drop-cap wp-block-paragraph">6När hemmakusken och nyzeeländaren Blair Orange vann gårdagens första avdelning i kusk-VM på Addington Raceway med Always A Menance gav det inte bara ett skutt uppåt i VM-tabellen. Vinsten var dessutom Oranges seger 3.000 i karriären!<br>47-årige Blair Orange är den fjärde kusken i Nya Zeeland att nå milstolpen och dessutom den yngste. Övriga som passerat 3.000 segrar är Tony Herlihy (3.719), Maurice McKendry (3.429) och Ricky May (3.190).</p>



<p class="wp-block-paragraph">Blair Orange kommer inte från någon travfamilj och tog sin första seger 1996. Sedan 2014 har han vunnit minst 100 lopp varje år och rekordsiffran är 267 från 2021. Han har vunnit kuskligan sju år i rad och tog över när Dexter Dunn – tio raka titlar – flyttade till Nordamerika och har klivit fram som den bäste kusken i USA.<br>– Jag var en medelmåtta när jag började, speciellt när man tittar på hur duktiga de unga kuskarna är idag, sade Blair Orange försynt efter jubileumssegern.</p>



<p class="wp-block-paragraph">Han representerar förstås hemlandet i det pågående världsmästerskapet, där han efter 15 av 20 körda lopp har fjärdeplatsen, fyra poäng bakom bronsmannen Mats E Djuse. Kusk-VM fortsätter i morgon bitti med fyra lopp innan det avslutande loppet körs på tisdag morgon.</p>



<p class="wp-block-paragraph"><strong>Ställning kusk-VM 2025 efter 15 lopp:</strong><br><em>Kusk – Land – Poäng</em></p>



<ol class="wp-block-list">
<li>James MacDonald – Kanada – 130</li>



<li>Gary Hall Jr – Australien – 121</li>



<li>Mats E Djuse – Sverige – 111</li>



<li>Blair Orange – Nya Zeeland – 107</li>



<li>Michael Nimczyk – Tyskland – 91</li>



<li>Pierre Vercruysse – Frankrike – 91</li>



<li>Giampaolo Minnucci – Italien – 83</li>



<li>Jaap Van Rijn – Nederländerna – 83</li>



<li>Brett Beckwith – USA – 80</li>



<li>Santtu Raitala – Finland – 80</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">7I finska Seinäjoki ligger stora pengar i potten i eftermiddag när det är dags för Breeders Crown-finalerna för tre- och fyraåriga hästar – Kasvattajakruun (€66.000). 30.000 euro väntar varje vinnare i de fyra finalerna.</p>



<p class="wp-block-paragraph">Den mest emotsedda finalen är kanske den för de treåriga hingstarna och valackerna, där Kriterievinnaren <strong>Ancio</strong> (e. Nuncio) vann ena försöket och Magnitude (e. Maharajah), son till finska stjärnstoet <strong>Mascate Match</strong> (e. Muscle Mass), vann det andra.</p>



<p class="wp-block-paragraph"><a href="https://heppa.hippos.fi/heppa/app?ct=YXBwbGljYXRpb24vcGRm&#038;d=dHJ1ZQ%3D%3D&#038;dr=&#038;f=b2hqZWxtYXRpZWRvdC5TXzA4LjExLjIwMjUucGRm&#038;m=AGrOH2a2qXWPQTz1y3jh7T8B88Q%3D&#038;service=pdftmp" target="_blank" rel="noreferrer noopener">Startlistorna till finalerna i Seinäjoki hittas här.</a></p>



<p class="wp-block-paragraph"><strong>Här är vinnarna i semifinalerna:</strong><br><em>Häst (far) – Tränare – Segertid</em></p>



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



<ul class="wp-block-list">
<li>Magnitude (e. Maharajah) – Hannu-Pekka Korpi – 1.13,7a/2.100 meter</li>



<li>Ancio (e. Nuncio) – Markku Nieminen – 1.13,9a/2.100 meter</li>
</ul>



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



<ul class="wp-block-list">
<li>E L Narnia (e. E L Titan) – Hannu-Pekka Korpi – 1.15,5a/2.100 meter</li>



<li>Skyfall Emelie (e. Friendly Bourbon) – Harri Koivunen – 1.14,6a/2.100 meter</li>
</ul>



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



<ul class="wp-block-list">
<li>Where’s The Party (e. Bar Hopping) – Niko Huuskola – 1.13,2a/2.100 meter</li>



<li>Neymar Web (e. Like A Prayer) – Anne Kangas – 1.15,6a/2.100 meter</li>
</ul>



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



<ul class="wp-block-list">
<li>Mint Match (e. Muscle Mass) – Pekka Korpi – 1.14,7a/2.100 meter</li>



<li>Ze On Alma (e. Harper Blue Chip) – 1.14,3a/2.100 meter</li>
</ul>

Fokustema
Sju nyheter vid sju
Läs senare
Fuxig favorit – och het kall duell
En slipad spik i V85-jackpotten? Wallins väg in i travsporten. Håller ledige Sjöström undan i Visby? VM-tvåa dyker upp i Holland. Blev landets yngste – som 47-åring.
Detta och mer bland lördagens nyheter.
Detta och mer bland lördagens nyheter.
