
<p class="has-drop-cap">12023 skrevs travhistoria för andra året i rad när Petri Salmela-tränade <strong>Joy Sisu</strong> (e. Brillantissime) vann Stochampionatet på nytt världsrekord, 1.12,5a/2.640 meter. Ifjol ”räckte” det med 1.13,4 av <strong>Kinglet Bird</strong> (e. Nuncio) för att vinna. Är det någon som kan utmana rekordet i eftermiddagens upplaga av Axevallas storlopp som kördes första gången 1969?</p>



<p>Gösta Nordins <strong>Goldhook</strong> (e. Tampiko) vann premiäråret och segertiden skrevs till 1.24,2a/3.100 meter. Tiden är faktiskt den långsammaste i historien, där distansen blev ett halvvarv kortare 1978 och fastställdes till dagens 2.640 meter. Först under 1.20 var <strong>May Björn</strong> (e. Björn), som tillsammans med Olle Goop travade 1.19,8 vid segern 1979. <br>Superstona Ina Scot och Lovely Godiva var bara tiondelar ifrån att kliva under 1.15 1993 respektive 1994, men först under den gränsen blev istället Stig H Johanssons <strong>Je T’Aime Dream </strong>(e. Sugarcane Hanover), som travade 1.14,5a 2003.</p>



<p>Först under 1.14 blev <strong>Neona Princess</strong> (e. Gigant Neo) och Johan Untersteiner för elva år sedan och 2021 sprängdes 1.13-vallen när Daniel Redéns <strong>Honey Mearas</strong> (e. Readly Express) vann på 1.12,8.</p>



<p>Försöken till årets upplaga var i de fleta fall av det lugnare slaget och en av sex vinnare travade under 1.14. André Eklundhs <strong>Panthere d’Inverne</strong> (e. Brillantissime) segrade på 1.13,9a/2.640 meter.<br>– Det var väldigt skönt att Panthere d’Inverne fick ett behagligt försök dessutom och ej behövdes bottnas. Det är en riktigt bra final med många stenhårda toppston, men jag har absolut ett av dem och det ska bli en väldigt spännande söndag, säger André Eklundh i Axevallas banprogram.</p>



<p><strong>Alla vinnarna av Stochampionatet under 1.14:</strong><br><em>År, häst (far) – Kusk (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2023 <strong>Joy Sisu</strong> (e. Brillantissime) –  Mka Forss (Petri Salmela) – 1.12,3a</li>



<li>2022 <strong>Great Skills</strong> (e. Ready Cash) – Daniel Wäjersten – 1.12,5a</li>



<li>2021 <strong>Honey Mearas</strong> (e. Readly Express) – Örjan Kihlström (Daniel Redén) – 1.12,8a</li>



<li>2017 <strong>Ultra Bright</strong> (e. Zola Boko) – Fredrik Persson – 1.13,0a</li>



<li>2013 <strong>Blended Scotch</strong> (e. Super Photo Kosmos) – Per Linderoth – 1.13,2a</li>



<li>2016 <strong>Galactica</strong> (e. Super Photo Kosmos) – Lars-Åke Söderholm (Malin Bergström) – 1.13,2a</li>



<li>2019 <strong>Activated</strong> (e. Jocose) – Carl Johan Jepson (Fredrik Wallin) – 1.13,2a</li>



<li>2024 <strong>Kinglet Bird</strong> (e. Nuncio) – Örjan Kihlström (Daniel Redén) – 1.13,4a</li>



<li>2018 <strong>Mellby Free</strong> (e. Muscle Hill) – Björn Goop – 1.13,5a</li>



<li>2015 <strong>Some Summit</strong> (e. Dream Vacation) – Veijo Heiskanen – 1.13,6a</li>



<li>2014 <strong>Neona Princess</strong> (e. Gigant Neo) – Johan Untersteiner (Peter Untersteiner) – 1.13,7a</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/2022/07/greatskillsdwm220725adamstromstalltz-617x396.jpeg" alt="" class="wp-image-331941"/><figcaption class="wp-element-caption">Stochampionatsvinnaren 2022: Great Skills. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">2Vid sidan om dagen clou Stochampionatet bjuds en hel del spännande lopp på Axevalla. Som en tidigare Stochampionatsvinnare och världsrekordhållare på startlinjen.<br>För tre år sedan spurtade Daniel Wäjersten hem sin dittills största seger som tränare och kusk när <strong>Great Skills</strong> (e. Ready Cash) vann Stochampionatet på 1.12,5a. Årets säsong inleddes med vinst i Påskägget i Gävle på skärtorsdagen, men sedan dess har det bara blivit en start: galopp på Bjerke för sex veckor sedan. Nu är hon tillbaka på banan i loppet som hedrar Mr Stall Palema – Karl-Erik Bender – som gick bort 2022 i en ålder av 87 år. <br>– Great Skills är allt bara bra med, vi har inget att klaga på. Det blev tyvärr en plump senast i Oslo, hon felade bort sig redan innan bilen släppte fältet, men hon såg bra ut efteråt. Vi vet alla vad hon kan i ljusa stunder och hon vann för övrigt just det här loppet ifjol. Jag tror på en bra prestation även i år, säger tränarbrodern Olle Wäjersten i Axevallas banprogram.</p>



<p>Nu ställs Great Skills mot <strong>Diva Ek</strong> (e. Trixton) som ståtar med sju raka segrar och närmast kommer från triumfen i Copenhagen Cup mot hingstarna för drygt två månader sedan. Det långa uppehållet och sjukdom (struken från en tilltänkt start i Kouvola i juni, reds. anm.) oroar inte tränare Alessandro Gocciadoro.<br>– Diva Ek blev väldigt sjuk med hög feber och halsinfektion, och fick strykas till Kymi Grand Prix. Det blev en paus på en dryg vecka innan hon tränats igång igen. Hon har inte gått något snabbjobb inför detta. Det ska dock sägas att hon klarar av att prestera efter paus, det har hon visat redan tidigare i år då hon vann årsdebuten utan att vara särskilt tempojobbad, säger Alessandro Gocciadoro på sin bloggsida.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/07/20v75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Axevallas söndagstävlingar.</a></p>



<p><em>Det är dessutom V75-spel till Axevalla idag och hos vår partner Simsalabim finns andelssystem.</em><br><a href="https://www.atg.se/simsalabim/V75_2025-07-20_8_6" target="_blank" rel="noreferrer noopener">Hitta dina andelar 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/2020/11/varennemal23-617x333.jpg" alt="" class="wp-image-119828"/><figcaption class="wp-element-caption">Världens bästa travare – är det Varenne? Foto Stefan Melander/stalltz.se</figcaption></figure>



<p class="has-drop-cap">3I de djupa skogarna i östra Finland på det pilsnabba underlaget och med den syrerika luften. Det var här <strong>Varenne</strong> vann på fenomenala 1.09,3 redan 2002 i en otrolig uppvisningsseger och 2020 vann finländske <strong>Next Direction</strong> på 1.08,9, men det är ingenting mot vad som hände 2023.</p>



<p>Svenskfödde <strong>Hierro Boko</strong> (e. From Above) och Santtu Raitala satte nytt löpningsrekord när han vann på 1.08,3, vilket då var den näst bästa tiden i Europa genom tiderna. Snabbast i Europa är franske <strong>Horsy Dream</strong> (e. Royal Dream) som travade 1.08,0a/1.609 meter när han vann Elitloppet förra året.</p>



<p><strong>Snabbaste vinnarna i S:t Michel Rce:</strong></p>



<ul class="wp-block-list">
<li>1.08,3 <strong>Hierro Boko</strong> (e. From Above) – Santtu Raitala – 2023</li>



<li>1.08,7 <strong>Don Fanucci Zet</strong> (e. Hard Livin) – Örjan kihlström – 2024</li>



<li>1.08,9 <strong>Next Direction</strong> (valack e. Orlando Vici) – Ilkka Nurmonen 2020</li>



<li>1.09,3 <strong>Varenne</strong> (hingst e. Waikiki Beach) – Giampaolo Minnucci 2002</li>



<li>1.09.4 <strong>Rapide Lebel</strong> (valack e. Ginger Somolli) – Eric Raffin 2011</li>
</ul>



<p>Årets upplaga av S:t Michel Race är en finnkamp, spetsad med italienaren Alessandro Gocciadoro. Daniel Redén tränade fjolårets vinnare <strong>Don Fanucci Zet</strong> (e. Hard Livin) och har två av åtta hästar i årets startfält, där han själv hoppar upp bakom Sweden Cup-vinnaren <strong>Double Deceiver</strong> (e. Cantab Hall).</p>



<p><a href="https://heppa.hippos.fi/heppa/app?ct=YXBwbGljYXRpb24vcGRm&#038;d=dHJ1ZQ%3D%3D&#038;dr=&#038;f=b2hqZWxtYXRpZWRvdC5NXzIwLjA3LjIwMjUucGRm&#038;m=L6jowYVSRCAWtVAYETwdWaBslYk%3D&#038;service=pdftmp" target="_blank" rel="noreferrer noopener">Här är startlistorna till stordagen i Mikkeli.</a></p>



<p><strong>Startlista S:t Michel-Ajo (€142.000)</strong><br>1.609 meter autostart, Mikkeli söndag<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li><strong>Banderas Bi </strong>(e. Ganymede) – Alessandro Gocciadoro</li>



<li><strong>Ubiquarian Face</strong> (e. Mosaique Face) – Janita Antti-Roiko</li>



<li><strong>Combat Fighter</strong> (e. From Above) – Santtu Raitala (Antti Ojanperä)</li>



<li><strong>Mellby Joke</strong>r (e. Muscle Hill) – Olli Koivunen (Daniel Wäjersten)</li>



<li><strong>Double Deceiver </strong>(e. Cantab Hall) – Daniel Redén</li>



<li><strong>Callela Nelson</strong> (e. Beer Summit) – Hannu Torvinen (Jukka Hakkarainen)</li>



<li><strong>Idomenio Sisu</strong> (e. Googoo Gaagaa) – Tuukka Varis (Petri Salmela)</li>



<li><strong>Crown </strong>(e. Chapter Seven) – Ulf Ohlsson (Daniel Redén)</li>
</ol>



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



<p class="has-drop-cap">4Vid sidan om Stochampionatshelgens avslutning på Axevalla tävlas det på ytterligare en svensk bana i eftermiddag. Till <strong>Hagmyren</strong> (första start 14.00) reser Gävletränaren Kevin Svedlund med stallets affischnamn <strong>Neymar Boko</strong> (e. Southwind Frank), som inte tävlat på nästan fyra månader.<br>Hästen kom till Svedberg i början av förra sommaren och hade ett urstarkt halvår från september till mars i år. Då vann han sex av 13 starter, däribland dubbla försök i rikstoton och dessutom slutade han tvåa i klass II-finalen i februari.</p>



<p>Neymar Boko har inte startat sedan han galopperade i klass I-finalen på Solvalla i mars, men är nu redo för comeback. Denna sker från tillägg i ett dubbelklasslopp, där <strong>Funcio</strong> (e. Nuncio) och <strong>One More Chance</strong> (e. Royalty For Life) finns bland motståndarna.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/07/250720.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</a></p>



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



<p class="has-drop-cap">5Den störste danske travhästen genom tiderna är <strong>Tarok</strong> (född 1972 e. Pay Dirt), som vann 111 lopp på 165 starter och vars popularitet i Danmark på 1970-talet var enorm.</p>



<p>2013 släpptes en spelfilm om Tarok och hans närmaste följeslagare Jörn Laursen, som gick upp i biosalongerna. Jörns son Jens – med hemmabana Axevalla – hustrun Katarina och dottern Saga är med i filmen, som beskrevs som ”en episk familjehistoria med den framgångsrika travhästen Tarok i centrum”. Anne-Grethe Bjarup Riis regisserade.</p>



<p>Tyvärr tog Taroks liv slut i januari 1981 när han drabbades av Baron Gruff-sjukan.</p>



<p>Idag på Charlottenlund hedrar Tarok med sitt egen minneslopp för ston över 2.000 meter. Johnny Takter kör Jörgen Lorentzen-tränade, svenskfödda <strong>Toscana Southwind</strong> (e. Bold Eagle), som bland annat ställs mot <strong>Gabi Kyvsgård</strong> (e. From Above U.S.) och svenska <strong>Glorius Rain</strong> (e. Donato Hanover).</p>



<p><a href="https://www.travbanen.dk/media/qevj0qyh/lunden_20-07-25_n.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Charlottenlunds 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/2021/11/kennethhaugstad-617x333.jpg" alt="" class="wp-image-236189"/><figcaption class="wp-element-caption">Kenneth Haugstad. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">614 hästar ska bli tolv när försöken i hingstarnas och valackernas klass i Biris Treåringselit körs på den norska banan idag. I stoklassen är det 22 treåringar anmälda. De låga siffrorna till trots – det var lika få hästar i förra årets upplagor av loppen som bjuder 300.000 kronor i förstapris i finalerna.<br>– Det är eländigt, men samtidigt förväntat. Det är bara att titta i historien hur det varit de senaste åren. Lika viktigt som antalet anmälda är dock att de bästa hästarna är med, så att vi får sportsliga bra lopp, och jag anser att loppet absolut har en framtid, säger Biris chef Stein Erik Roböle till Trav- og Galopp-Nytt.</p>



<p>Fast som det verkar på Robäle blir det i ny skepnad nästa år. Utan kvalificeringslopp. Så är upplägget för motsvarigheten på kallblodssidan, Biris Uppfödningslopp, där de anmälda hästarna seedad och de med högst ranking får tävla i det stora loppet och – om tillräckligt många anmälts – övriga för starta i ett tröstlopp.</p>



<p>En svensktränad häst försöket kvala till det norska storloppet. Kenneth Haugstad reser med hingsten <strong>Who’s Here</strong> (e. Who’s Who), som vunnit ett lopp hittills. Who’s Here behöver bara slå en häst för att gå till final,</p>



<p>Biris Treåringselit hette från 1985 Prinsesse Märthe Louises Pokallopp, men i höstas avslutades samarbetet med norska hoven om namnet på det stora treåringsloppet.</p>



<p><a href="https://www.travsport.no/travbaner/biri-travbane/startlist/2025-07-20" target="_blank" rel="noreferrer noopener">Här är startlistorna till unghästförsöken på Biri.</a></p>



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



<p class="has-drop-cap">7Solvallaamatören, uppfödaren, ägaren och kusken Alf Nordemo har en späckad eftermiddag på gräsbanan <strong>Clairefontaine </strong>i Deauville. Hela fyra av hans hästar i träning hos Ron Kuiper startar på gräset. Kuiper kör tre av dem, men den fjärde hoppar Nordemo själv upp bakom.</p>



<p>I en kuskmatch mellan svenska och franska amatörer kör Nordemo <strong>Julie du Nord</strong> (e. Un Mec d’Heripre). Övriga svenska kuskar är Susanna Ehrström, Mattias Eriksson och Leif K Karlsson. Nordemo har kört tolv lopp i Frankrike tidigare, medan övriga svenskar gör kuskdebut i landet.<br>Nordemos övriga starthästar på Clairefontaine är <strong>Kathleen du Nord</strong> (e. Un Mec d’Heripre), <strong>Lamelle du Nord</strong> (e. Gu d’Heripre) och <strong>Lynx du Nord</strong> (e. Un Mec d’Heripre), som tävlar i lopp med 14.000-14,500 europ i total prissumma.</p>



<p>Jarmo Niskanen startar <strong>Kai La Sha</strong> (e. Earl Simon) i ett femåringslopp i <strong>Gournay-en-Bray</strong> med 14.00 euro i prispotten. Hästen har ett lopp i kroppen efter långt uppehåll.</p>
