
<p class="has-drop-cap">1Svenskt Mästerskap föddes på Jägersro 1939 då Sören Nordin vann med <strong>Quart Axworthy</strong> (e. Fels) och precis som många andra stora löpningar i Sverige så alternerade värdskapet för loppet mellan de tre storstadsbanorna Jägersro, Solvalla och Åby under många år. Sedan 1966 är SM bofast på Åby.</p>



<p>SM-kungen i Sverige då? Tolv segrar i Svenskt Mästerskap räknade just Sören Nordin in under sin fantastiska tränarkarriär i Sverige och hälften av vinsterna kom med travdrottningen <strong>Frances Bulwark</strong> (e. Bulwark). <br>Stig H Johansson skuggar en seger bakom Sören med sina elva triumfer. Dessa togs med sju olika hästar, där en annan travdrottning <strong>Queen L.</strong> (e. Crowntron) var främst i klassen med tre triumfer. Ytterligare en travare vann SM tre gånger: Sixten Lundgrens <strong>Balett</strong> (e. Bulwark).</p>



<p>I eftermiddag på Åby (första start 13.30) är det dags för årets upplaga, som blivit en vidöppen sådan. Igår ströks nämligen den store förhandsfavoriten <strong>Epic Kronos</strong> (e. Muscle Hill) på grund av hovböld.</p>



<p>Titelförsvarare på tränarsidan är Daniel Redén, vars <strong>Francesco Zet</strong> (e. Father Patrick) satte världsrekord 1.11,1a/2.640 meter när han vann SM förra året. Trots strykningen av Epic Kronos har Redén två kandidater kvar till SM-guld. En av dem är <strong>Kentucky River</strong> (e. Father Patrick) med 8,7 miljoner kronor på kontot. En halv miljon av dessa slog han in som tvåa i Sundsvall Open Trot för fyra veckor sedan.<br>– Kentucky River avslutade jättebra bakom Epic Kronos i Sundsvall och han är verkligen en riktig hedershäst som aldrig gör oss besvikna. Han har tränat på som vanligt efter det och läget blev perfekt och distansen gillar han, säger Daniel Redén på sin hemsida <a href="http://reddis.se" target="_blank" rel="noreferrer noopener">reddis.se</a>.</p>



<p><strong>Flest tränarsegrar i Svenskt Mästerskap:</strong></p>



<ul class="wp-block-list">
<li>Sören Nordin – 12</li>



<li>Stig H Johansson – 11</li>



<li>Gösta Nordin – 5</li>



<li>Svante Båth – 3</li>



<li>Olle Goop – 3</li>



<li>Stefan Hultman – 3</li>



<li>Sixten Lundgren – 3</li>



<li>Gunnar Nordin – 3</li>



<li>Åke Svanstedt – 3</li>
</ul>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/08/unforgettableaydwm260819adamstromstalltz-617x419.jpg" alt="" class="wp-image-888280"/><figcaption class="wp-element-caption">Unforgettable A.Y. och Daniel Wäjersten. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">2Sto-SM har inte lika lång historia och länge tävlade de främsta stona mot hingstarna i Svenskt Mästerskap. Framgångarna var också stora för det täcka könet. Visserligen vann hingstar – Quart Axworthy, O.Ke Hanover och Big Noon (två gånger) – de fyra första upplagorna, men 13 gånger de 19 första åren var det ett sto i topp i SM med drottningen Frances Bulwark som dominant med sex titlar.</p>



<p>Stonas eget svenska mästerskap hade premiär 1987 när Little Brown Jug (e. Pershing) och Roger Grundin segrade och sedan Spader Madames (e. Atas Fighter L.) triumf 2000 har förstapriset varit lika högt i båda klasserna.</p>



<p>Med sex raka segrar får Markus Pihlströms raket <strong>Unforgettable A.U.</strong> (e. From Above) fått verkliga elddop efter att ha radat upp toppinsatser hela sommaren. Hon ställs mot sitt tuffaste motstånd i karriären med etablerade, klassiska vinnare som <strong>Daim Brodda</strong> (e. Readly Express) och <strong>La Yuca</strong> (e. Face Time Bourbon) bland motståndarna.<br>– Det är svårt att sätta in henne i loppet, men jag kommer med en häst som är otroligt fin och kommer att göra sitt livs lopp. Hon tränar så bra och om jag känner rätt gör hon sitt bästa lopp i karriären. Det är mycket spänst i henne, Daniel körde ett jobb med henne förra veckan och han var lyrisk, och det var jag också efter veckans jobb. Från bra spår hade det varit en bra chans, men nu är hon lite utlämnad till de andra från det här spåret, sade Markus Pihlström till V65 Direkt.</p>



<p>Totalt ska det delas ut sju SM-guld på Åby under eftermiddagen och det sista är öppna klassen.</p>



<p><strong>Så här gick det förra året:</strong></p>



<ul class="wp-block-list">
<li>Svenskt Mästerskap: <strong>Francesco Zet</strong> (e. Father Patrick) – Örjan Kihlström (Daniel Redén)</li>



<li>Sto-SM: <strong>Great Skills</strong> (e. Ready Cash) – Daniel Wäjersten</li>



<li>Monté-SM: <strong>Joy Alissa</strong> (e. Maharajah) – Emilia Leo (Olle Alsén)</li>



<li>Amatör-SM: <strong>Fancy Free</strong> (e. Panne de Moteur) – Niclas Benzon (Lisa Skogh)</li>



<li>Lärlings-SM: <strong>Kemper Boyd</strong> (e. Googoo Gaagaa) – Valentin Prevost (Robert Bergh)</li>



<li>Ungdoms-SM: <strong>Monsieur Chocolat</strong> (e. Bird Parker) – Fredrik Plassen (Fredrik Wallin)</li>



<li>Montéryttar-SM: <strong>Django Silver</strong> (e. Django Riff) – Emilia Leo (Ulf Stenströmer)</li>



<li>Dam-SM*: <strong>Bollinger N.O.</strong> (e. Father Patrick) – Jessica Schade Lundell (Björn Goop)</li>
</ul>



<p><em>* Finalen i Dam-SM hålls i Eskilstuna söndag den 4 oktober.</em></p>



<p>Sulkysports expertpanel har synat omgången och levererar sina bästa spikar och roliga skrällar i SM-omgången på Åby – kolla in V85-dragen här!</p>



<p><em>Vill du spela andelsspel tillsammans med Sulkysports panel? Här finns olika alternativ:</em></p>



<p><a href="https://www.atg.se/butik/simsalabim/V85_2026-09-26_6_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Simsalabim.</a></p>



<p><a href="https://www.atg.se/butik/69ansspel/V85_2026-09-26_6_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos 69:ans Spel &#038; Tobak.</a></p>



<p><a href="https://www.atg.se/butik/spelpoolen/V85_2026-09-26_6_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Spelpoolen.</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/2026/09/mellbynarrowmadm260906adamstromstalltz-617x419.jpg" alt="" class="wp-image-894905"/><figcaption class="wp-element-caption">Mellby Narrow och Magnus Djuse vinner Derbyt 2026. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">3Tre banor och totalt fem uttagningslopp väntar inför finalen i Europaderbyt Grand Prix de l’U.E.T. i Turon den 11 oktober. De två första kördes på Vincennes igår kväll och vanns av xxxx – läs mer här.</p>



<p>Idag väntar två försök på Åby innan V85-spelet drar igång innan det avslutas med ett femte och sista i Milano i morgon.</p>



<p>Till Åby kommer den nybakade svenske Derbyvinnaren <strong>Mellby Narrow</strong> (e. Maharajah), där tränaren Daniel Wäjersten åter sitter i vagnen. I Derbyt var det Magnus A Djuse vid segertömmarna.<br>– Han var väldigt nöjd och belåten när han kom hem efter Derbyt. Det har inte funnits någon anledning att kolla upp honom, utan han har tränat på som vanligt. Det är en häst som varit jämn och bra hela vägen och visade att det är något extra när det gällde. Två lopp över lång distans på kort tid är tufft, men han visade att hans jämnhet gav utslag, sade Daniel Wäjersten till V65 Direkt.</p>



<p>Mellby Narrow möter en annan Derbyvinnare i försöket: Johan Untersteiner-tränade <strong>Lazy Dust</strong> (e. Brillantissime) som tog hem travets blå band i Danmark.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/09/26v85.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Åbys tävlingar idag.</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/2023/06/stoletheshowdexterdunn-617x333.jpg" alt="" class="wp-image-452132"/><figcaption class="wp-element-caption">Stoletheshow tillsammans med Dexter Dunn i Elitloppet 2023. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">4Efter norskt mästerskap på Biri i somras tackade svenskägde <strong>Stoletheshow</strong> (e. Dream Vacation-Abba Hall e. Garland Lobell), 1.09,5ak/15.018.689 kr, för sig på tävlingsbanan efter en sagolik karriär. Nu väntar ett nytt äventyr – som avelshingst i Finland. Det berättar <a href="https://tgn.no/dette-blir-stoletheshows-nye-liv/19.37601" target="_blank" rel="noreferrer noopener">norska Trav- og Galopp-Nytt</a>.<br>– Han har gjort sig ett namn i Finland, då han vann Finlandia-Ajo två år på raken. Nu har han rest till Sverige för att gå igenom en del tester innan han startar sin avelskarriär i Finland, säger Frode Hamre till TGN.</p>



<p>Totalt gjorde hingsten 119 starter (45-23-12) och det ryms en hel del storloppsvinster bland dessa. Eller vad sägs om denna segerlista: <br>Norskt Travkriterium (2018), Hans Petter Tholfsens Minneslopp (2018), Oslo Grand Prix (2022), Ulf Thoresen Grand International (2022), C.Th. Ericssons Memorial (2022), Norskt Mästerskap (2022, 2023 och 2024), Finlandia-Ajo (2023 och 2024), Prins Daniels lopp (2024).<br>– Det kändes vemodigt när han lämnade. Det är den häst som betytt mest för mig under hela karriären. Han har gett mig så mycket glädje, säger Frode Hamre.</p>



<p>Stoletheshow är svenskägd, av Global Glide AB (Süleyman Yüksel).</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/08/janolovpersson2-617x333.jpg" alt="" class="wp-image-478961"/><figcaption class="wp-element-caption">Jan-Olov Persson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">52005 vann Jan-Olov Person treåringsloppet Biris uppfödningslopp med <strong>Faksen J:r</strong> (e. Järvsöfaks) och två år senare slog han till med <strong>Järvsöviking</strong> (e. Järvsöfaks). Idag har Hagmyrentränaren två chanser att ta en tredje titel i de treåriga kallblodens tredje största största lopp bakom svenska och norska Kriteriet med 300.000 norska kronor i förstapris. </p>



<p>Årets upplaga blir ett häftigt möte mellan svenske Kriterievinnaren <strong>Björli Bas</strong> (e. Brenne Bas) från Öystein Tjomslands stall och norske Kriterievinnaren, Persson-tränade <strong>Skiffer</strong> (e. Lome Brage).<br>Kallblodssportens två dominanter kör själva sina hästare i storloppet. Tjomsland straffar Persson rejält på förhand med hela sju tränatsegrar (<strong>Håkon Jo, Tekno Odin, Rappstjernen, Grisle Odin G.L., Tangen Bork, Tangen Minto</strong> ochh <strong>Bore Mikkel</strong>).</p>



<p>Persson har ytterligare en häst i loppet, <strong>Järvsö Anton</strong> (e. Järvsö Björn), som får sitt elddop i tuff unghästkonkurrens.</p>



<p>Vid sidan om det stora treåringsloppet bjuds flera vassa lopp för den kalla rasen under tävlingsdagen som är förbehållen kallblod.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/09/26biri.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Biris tävlingar.</a></p>



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



<p class="has-drop-cap">6Alessandro Gocciadoros femåriga toppsto <strong>Funny Gio</strong> (e. Face Time Bourbon), 1.08,9/€699.224, får göra resan till Sicilien och banan i Palermo idag. Där avgörs Gran Premio Regione Sicilia (€121.000) över sprinterdistans med startbil och Funny Gio har dragit innerspår.<br>Hon kommer närmast från fjärdeplatsen i Hugo Åbergs Memorial, där hon travade 1.08,9a/1.609 meter i loppet som vanns av <strong>Allegiant</strong> före <strong>Daim Brodda</strong> och <strong>Mellby Jinx.</strong></p>



<p>Fanny Gio har vunnit 18 av 30 starter hittills i karriären, bland annat italienska uppfödningsloppet Gran Premio Allevatori, Gran Premio Continentale och Gran Premio Freccia d’Europa.</p>



<p><strong>Startlista Gran Premio Regione Sicilia (€121.000)</strong><br>1.600 meter autostart<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li><strong>Funny Gio</strong> (e. Face Time Bourbon) – Alessandro Gocciadoro</li>



<li><strong>Ettore Trebi</strong> (e. Nad Al Sheba) – Andrea Buzzitta</li>



<li><strong>Emma Dei Veltri</strong> (e. Maharajah) – Vincenzo Luongo</li>



<li><strong>Golimpio d’Or</strong> (e. Dontyouforgetit) – Mario Minopoli J:r</li>



<li><strong>Finalmente Par</strong> (e. Varenne) – Giorgio d’Alessando S:r</li>



<li><strong>Dali Prav</strong> (e. Donato Hanover) – Rene Legati</li>



<li><strong>Dylan God Font</strong> (e. Ringostarr Treb) – <em>struken</em></li>



<li><strong>Fierobecco Font</strong> (e. Ringostarr Treb) – Filippo Gallo</li>



<li><strong>Edgar Saba </strong>(e. Exploit Caf) – Francesco Facci</li>



<li><strong>Edy Girofalco Gio</strong> (e. Victor Gio) – <em>struken</em></li>



<li><strong>Eleomeda Jet</strong> (e. Wishing Stone) – Salvatore Cintura J:r</li>



<li><strong>Gigia Da</strong> (e. Ginger Up) – Gaspare Lo Verde</li>
</ol>



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



<p class="has-drop-cap">7Sju gånger i historien har Markku Nieminen tränat vinnaren i finska Kriteriet, däribland Ancio (e. Nuncio) ifjol. Idag i Tammerfors kan han ordna en åttonde titel när han har två försöksvinnare i final i stoet Donna Madeleine (e. Maharajah) och Coriolanus Frido (e. Calgary Games).</p>



<p>Mika Forss körde Donna Madeleine till försöksvinst i försöket och är tillbaka även i finalen, medan Nieminen själv hoppar upp bakom Coriolanus Frido för första gången i lopp. Santtu Raitala körde uttagningsloppet, men är avstängd.</p>



<p>Coriolanus Frido är favorit på förhand och utmanas i första hand av snabbaste kvalvinnaren Better Leader (e. Readly Express) och Pinebog’s Bank (e. Readly Express).</p>



<p>För den äldre eliten väntar final i Pohjantähti Grand Championship (€53.750) med 25.000 euro till vinnaren. Tre försök kördes förra veckan och vanns av svenskfödda duon Dozen of Oysters (e. Zola Boko) och Need’em (e. Propulsion), samt Amazing Player (e. Quite Easy), som inleder från de tre innersta spåren bakom bilen över 2.100 meter. Ytterligare fem blågula travare finns i finalfältet, däribland Combat Fighter (e. From Above), som får Jorma Kontio i vagnen.</p>



<p><strong>Startlista Finskt Travkriterium (€181.000)</strong><br>2.600 meter autostart<br><em>Namn (far) – Tränare</em></p>



<ol class="wp-block-list">
<li><strong>Donna Madeleine</strong> (e. Maharajah) – Mika Forss (Markku Nieminen)</li>



<li><strong>Coriolanus Frido</strong> (e. Calgary Games) – Markku Nieminen</li>



<li><strong>Pinebog’s Bank</strong> (e. Readly Express) – Hannu Torvinen (Riina Korhonen)</li>



<li><strong>Cortina Games</strong> (e. Calgary Games) – Henri Bollström (Antti Kinnunen)</li>



<li><strong>Reason To Rock</strong> (e. Express Duo) – Pekka Korpi (Hannu-Pekka Korpi)</li>



<li><strong>Miss White Gold</strong> (e. Maharajah) – Iikka Nurmonen (Hannu-Pekka Korpi)</li>



<li><strong>Mas Knockout</strong> (e. Six Pack) – Kimmo Kemppi (Mika Haapakangas)</li>



<li><strong>Canberra Eastwind</strong> (e. Readly Express) – Tapio Perttunen</li>



<li><strong>Better Leader</strong> (e. Readly Express – Ville Koivisto (Petri Klemola)</li>



<li><strong>Heartbeat Ahead</strong> (e. Maharajah) – Jukka Torvinen (Juho Ihamuotila)</li>



<li><strong>Amon Amarth</strong> (e. Maharajah) – Tommi Kylliäinen (Christa Packalén)</li>



<li><strong>Kajas Poseidon</strong> (e. Vivid Wise As) – Olle Koivunen (Harri Koivunen)</li>
</ol>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/09/26tammerfors.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Tammerfors Kriteriedag.</a></p>
