
<p class="has-drop-cap">1Idag den 26 juli fyller än Stig H Johansson 80 år och han hyllas med ett eget lopp på barndomsbanan Hagmyren. Första segern tog han just på Hagmyren bakom <strong>Zabrina</strong> den 25 augusti 1963 och den skulle följas av ytterligare 6.224 som kusk. Som tränare blev det 8.206 segrar och med det är han bäst genom tiderna i Sverige.</p>



<p>Totalt sprang Stig H Johanssons hästar 853.588.855 kronor och hans toppår var 2002 med nästan 43 miljoner, varav drygt tio miljoner signerade <strong>Victory Tilly</strong>. Under 31 år sprang hans travare in tio miljoner kronor eller mer, första gången var redan 1985.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/02/victorytillyshjtzelitloppet000528-617x333.jpg" alt="" class="wp-image-548336"/><figcaption class="wp-element-caption">StigH Johanssons största seger med sin största stjärna: Victory Tilly vann Elitloppet 2000. Tvåa slutade franske General du Pommeau. Foto Stalltz.se</figcaption></figure>



<p><strong>Stig H Johanssons meritlista är evighetslång. Här är några punkter: </strong></p>



<ul class="wp-block-list">
<li>8.206 tränarsegrar</li>



<li>6.225 kusksegrar, varav över 1.000 i rikstoton (V65/V75),</li>



<li>29 Solvallachampionat som kusk (1975, -77, sedan 1979-2005 i svit)</li>



<li>Nio allsvenska kuskchampionat (1977, -83, sedan 1987-1993 i svit)</li>



<li>Sex Elitloppssegrar (The Onion 1984, Utah Bulwark 1987, Napoletano 1989, Peace Corps 1991, Gum Ball 1997 och Victory Tilly 2000)</li>



<li>Sju Derbysegrar (Segerstorp Comet 1970, Grain 1974, Rex Håleryd 1982, Big Star 1984, Queen L. 1990, Victory Tilly 1999, S:t Göran 2000)</li>



<li>Fem Kriteriesegrar (Grain 1973, Mack The Knife 1984, Piper Cub 1986, Union Shark 1990, Pont Neuf 1991)</li>



<li>Sju Stochampionatssegrar varav sex med egentränade hästar (Holly Rodney 1977, Gina Roy 1987, Queen L. 1990, Bowls Lady 1991, Fiona San 1995, Je T’Aime Dream 2003 samt lånekörde Varia 1981).</li>



<li>Världsrekord 1.08,9 med Victory Tilly i Nat Ray Trot på Meadowlands 2002. The Onions världsrekord 1.12,0a/1.609 när han vann Sprintermästaren 1983 chockade – det absoluta världsrekordet för äldre hästar på tusenmetersbana var då 1.12,8.</li>



<li>Seger med Queen L. i Prix d’Amerique 1993.</li>



<li>Tränat tre svenskfödda hästar som kommit in på tiomiljonerlistan intjänat: Victory Tilly 37,7 mkr, Digger Crown 18,2 mkr, Queen L. 17,5 mkr.</li>
</ul>



<p>Tidigare i sommar berättade Stig H:s hustru Karin att maken är sjuk i alzheimer. Idag bor Stig H på ett särskilt boende nära Stora Alby. Födelsedagen tillbringar med familjen som lämnat följande önskemål: Familjen önskar att Stigs vänner, bekanta och övriga i stället för blommor betänker Stig H Johanssons Stipendiefond (bankgiro 398-7765) och/eller Stiftelsen Alzheimer Life (bankgiro 5587-4564).</p>



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



<p class="has-drop-cap">2Många fina travnamn hyllas och hedras på Hagmyren (första start 14.45) idag. Som Ernst Johan Nordin (1887–1957. Han lade grunden till en dynasti inom svensk och internationell travsport, där sönerna Gösta, Gunnar och Sören kom att dominera i långt mer än ett halvt sekel. Efter att ha verkat som tränare i Näsviken i Hälsingland flyttade Ernst Johan söderut till Solvalla där han bland annat blev kuskchampion 1929.</p>



<p>Sedan 1965 hedras ”balanseringskonstens mästare” med E.J.’s Guldsko på Hagmyren. de två senaste åren har det krävts en tid under 1.10 för att vinna. För två år sedan travade <strong>Zeudi Amg</strong> (e. Ideale Lous) 1.09,9a och ifjol pressade<strong> Global Badman</strong> (e. Yield Boko) löpningsrekordet en tiondel till med 1.09,8.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/06/oscarl.a.heat-617x333.jpg" alt="" class="wp-image-732820"/><figcaption class="wp-element-caption">Alessandro Gocciadoro-tränade Oscar L.A., här med Magnus A Djuse, startar på Hagmyren idag. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Snabbast bland årets deltagare är Alessandro Gocciadoro-tränade <strong>Oscar L.A.</strong> (e. Ready Cash), som satte banrekord i Tingsryd på 1.08,5a/1.609 meter i början av sommaren. Han kommer dock från en slätstruken prestation i Halmstad under Sprintermästarhelgen.<br>– Oscar L.A. var bara sådär senast. Han var inte dålig, men inte heller bra. Han fick en veckas paus efter och kan haft en lättare halsinfektion. Det är något som våra hästar haft en del problem med i sommar och som legat till grund för att stallets hästar presterat väldigt ojämnt. Han fick en kort paus, men har tränat på bra igen och ska kunna göra en bra prestation, säger Alessandro Gocciadoro på sin bloggsida.</p>



<p>Sulkysports tipster Fredrik Persson på <a href="https://simsalabim.se/travtips/" target="_blank" rel="noreferrer noopener">Simsalabim</a> streckar fyra hästar i loppet, däribland Oscar L.A.</p>



<p><strong><a href="https://sulkysport.se/spelstugan/v75-hagmyren-lordag/" target="_blank" rel="noreferrer noopener">––> Här är tipsgenomgången med viktiga punkter, spikar, drag och systemförslag på V75.</a></strong></p>



<p><em>Vill Du spela V75 tillsammans med Sulkysport?</em><br><a href="https://www.atg.se/simsalabim/spel/307468_V75_2025-07-26_17_5" target="_blank" rel="noreferrer noopener">Här finns andelar till systemförslaget hos Simsalabim för 150 kr/andel.</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/2024/09/maryland1392024deangillette-617x347.jpg" alt="" class="wp-image-634043"/><figcaption class="wp-element-caption">Marcus Melanders Maryland och Dexter Dunn. Foto: Dean Gillette</figcaption></figure>



<p class="has-drop-cap">3Tio svensktränade hingstar/valacker i försök till Hambletonian och tolv ston i kvalen till Hambletonian Oaks. Det kan bli en riktig blågul afton på Meadowlands i väntan på de stora finalerna nästa lördag.</p>



<p>Marcus Melander har flyttat fram positionerna på andra sidan Atlanten och vunnit rader av storlopp, men Hambletonian Stakes saknas på meritlistan. I år har han laddat rejält med fem hästar totalt i de tre försöken, däribland fjolårets kung <strong>Maryland</strong> (e. Chapter Seven) och en av de som imponerat mest i år, Yonkers Trot-vinnaren<strong> Super Chapter</strong> (e. Chapter Seven).</p>



<p>Nancy Takter har vunnit Hambletonian Stakes två år i rad som tränare, men saknar häst i årets upplaga. För två år sedan med <strong>Tactical Approach</strong> och ifjol med <strong>Karl</strong>, båda hingstarna med Tactical Landing som far. </p>



<p>Åke Svanstedt har också vunnit Hambot två gånger, med <strong>Perfect Spirit</strong> (e. Andover Hall) och <strong>Captain Corey</strong> (e. Googoo Gaagaa), och har en häst i vardera försök.</p>



<p>Två av Åke Svanstedts tre bidrag är svenskfödda, <strong>Gap Kronos</strong> (e. Face Time Bourbon) och <strong>Nordic Catcher</strong> (e. Six Pack), och detsamma gäller Lucas Wallins Hambohopp <strong>Maximus Mearas</strong> (e. Chapter Seven)</p>



<p>Tre blågula hästar i försöken är det näst flest historiskt sett. Endast 2022 års Hambletonian slår det när fem svenskfödda travare var med i försöken, däribland finaltvåan <strong>Joviality</strong> (e. Chapter Seven). Fortfarande har ingen svenskfödd travare gått hela vägen till triumf. Förutom Joviality har även<strong> King Conch</strong> (e. Speedy Crown) och <strong>Mr Lavec</strong> (e. Speedy Somolli) varit närmast slagna.</p>



<h2 class="wp-block-heading">Svenskfödda hästar i Hambletonian: </h2>



<p><em>Namn – Placering (försök-final) – År</em></p>



<ul class="wp-block-list">
<li>Lass Quick – 0 (4-10) – 1983</li>



<li>King Conch – 2 (1-2) – 1992</li>



<li>King Lavec – 0 (5-6) – 1993</li>



<li>Mr Lavec – 2 (2-2) – 1994</li>



<li>Easy Lover – 0 (7-X) – 1995</li>



<li>Kramer Boy – 4 (3-4) – 1996</li>



<li>Enjoy Lavec – 3 (3-3) – 1999</li>



<li>Primary Ås – 0 (4-X) – 2007</li>



<li>Green Manalishi – 5 (1-5) – 2019</li>



<li>Jiggy Jog – 4 (1-4) – 2022</li>



<li>Joviality – 2 (3-2) – 2022</li>



<li>Letsdoit – 0 (9-X) – 2022</li>



<li>Zephyr Kronos – 0 (8-X) – 2022</li>



<li>Thereisnolimit – 0 (8-X) – 2022</li>



<li>Gap Kronos – 2025</li>



<li>Maximus Mearas –  2025</li>



<li>Nordic Catcher – 2025</li>
</ul>



<p>På stosidan i Hambletonian Oaks mönstrar Marcus Melander och Nancy Takter tre hästar vardera, Åke Svanstedt och Lucas Wallin har en duo, medan Jenny Melander och Jim Oscarsson kvalar en häst var.</p>



<p><a href="https://sulkysport.se/tio-blagula-chanser/" target="_blank" rel="noreferrer noopener">Här är hästarna i försök till Hambletonian Stakes.</a></p>



<p><a href="https://sulkysport.se/tolv-svensktranade-till-start/" target="_blank" rel="noreferrer noopener">Här är hästarna i försök till Hambletonian Oaks.</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/2025/06/jabalpurscoopdyga-617x333.jpg" alt="" class="wp-image-734293"/><figcaption class="wp-element-caption">Jabalpur och Gabriele Gelormini. Foto Scoopdyga</figcaption></figure>



<p class="has-drop-cap">4Ett riktigt stjärnmöte bjuds på på Paris-banan Enghien i eftermiddag i Prix Jean-Luc Lagardere (€150.000) över 2.875 meter. Då gör Alain Chavattes världsrekordhållare, sexåringen <strong>Jabalpur</strong> (e. Booster Winner), första starten sedan han besegrade Elitloppsvinnaren <strong>Go On Boy</strong> (e. Password) och vann Grupp I-loppet Prix Rene Balliere (€200.000) 1.08,7a/2.100 meter.</p>



<p>I andra ringhörnan finns en häst som gjort Vincennes till sitt hem. Med nio raka segrar på kolstybben byter Laurent Claude Abrivard-tränade <strong>Inexess Bleu</strong> (e. Vittel de Brevol) bana i Paris för att förlänga sin segersvit.</p>



<p>I loppet gör även vinterns Prix d’Amérique-tvåa <strong>Just Love You</strong> (e. Love You) comeback efter att ha opererat bort en lös benbit efter Pd’A.</p>



<p>Fem av Enghiens nio lopp idag är öppna för europeiska hästar, men det svenska intresset är minst sagt svalt och bara två svenskfödda travare kommer till start. Jägersroamatören Elke Frinta låter femåriga stoet <strong>Perfect</strong> (e. Southwind Frank) prova vingarna för första gången på fransk mark i Prix de la Celle-Saint-Cloud (€41.000) över 2.875 meter.</p>



<p>I Prix de l’Hay-les-Roses (€46.000) startar svenskägde <strong>Underground Artist</strong> (e. Royalty For Life), som gör debut för Alexandre Blodneau. Hästen hann göra två starter för den från och med idag dopingavstängde Romain Derieux.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/enghien-2025-07-26/" target="_blank" rel="noreferrer noopener">Här är startlistorna till Enghiens tävlingar.</a></p>



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



<p class="has-drop-cap">5Efter dubbla natt-trav i Sverige igår (Romme och Halmstad) kommer ett nytt ikväll. Kalmar (första start 19.30) har sin sena tävlingskväll sommartid och höjdpunkten är Sommarduellen med försök och final samma kväll.</p>



<p>Sprinterdistans och startbil för hästar i två klasser gäller i försöken, medan finalen avgörs över medeldistans med hästar på två volter. Åbytränaren Christoffer Eriksson har tre hästar till start i de två försöken och bland dem finns femårige <strong>Ferrara</strong> (e. Readly Express), som matchats i tuffare gäng på sistone.</p>



<p>Annars kan försöket i treåringsserien bli sevärt med Johan Untersteiners danskfödde talang <strong>Lazy Dust</strong> (e. Brillantissime) mot Per Nordströms <strong>Fleetfoot S.S.</strong> (e. Factical Landing). Lazy Dust har inlett med seger i livets enda start, medan Fleetfoot S.S. debutvann på 1.15,4m innan han har gjort bort sig med galopp två gånger efteråt.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/07/250726.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens tävlingar på svensk mark.</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/09/pekkakorpidef-617x333.jpg" alt="" class="wp-image-209004"/><figcaption class="wp-element-caption">Pekka Korpi. Foto Mia Törnberg/Sulkysport</figcaption></figure>



<p class="has-drop-cap">6Vilket är Finlands bästa treåriga sto? Idag gör kullens ston upp i säsongens största lopp hittills, Tammakriterium (€43.000) i Tammerfors. Uttagningsloppen kördes för elva dagar sedan och de två storfavoriterna på förhand vann varsitt.</p>



<p>Pekka Korpi-tränade <strong>Fuego Combo</strong> (e. Express Duo) har tagit positionen som etta och vann sitt försök på 1.13,8a/2.100 meter med tränaren i vagnen. I dagens final hoppar finske kuskettan Santtu Raitala upp. Fuego Combo har hunnit med 14 starter och vunnit tio av dessa.<br>Hannu-Pekka Korpi-tränade <strong>E L Narnia</strong> (e E L Totan) tog hem det andra försöket på 1.14,0a tillsammans med Hannu Torvinen.</p>



<p><strong>Startlista Stokriteriet (€43.000)</strong><br>2.100 meter autostart, Tammerfors lördag<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li><strong>E L Narnia</strong> (e. E L Titan) – Hannu Torvinen</li>



<li><strong>Fuego Combo</strong> (e. Express Duo) – Santtu Raitala</li>



<li><strong>Lafayette</strong> (e. Royalty For Life) – Jarmo Saarela</li>



<li><strong>Arctic Fiona</strong> (e. Maharajah) – Janne Korpi</li>



<li><strong>Aleida Mania</strong> (e. Diamond Duo) – Iikka Nurmonen</li>



<li><strong>Sister Serene</strong> (e. Father Patrick) – Tommi Kylliäinen</li>



<li><strong>Lily Lee Hoss</strong> (e. Nuncio) – Olli Koivunen</li>



<li><strong>Emiliana</strong> (e. Saharah Dynamite) – Ari Mailanen</li>



<li><strong>Lady Gaagaa</strong> (e. Googoo Gaagaa) – Juha Utala</li>



<li><strong>Himma’s Here I Am</strong> (e. Quite Easy) – Henri Bollström</li>



<li><strong>Fanny’s Adhara</strong> (e. Maharajah) – Emma Väre</li>



<li><strong>Green Lee</strong> (e. Greenshoe) – Pertti Puikkonen</li>
</ol>



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



<p class="has-drop-cap">7En hel del svenskar gör turen över gränsen till norska Momarken (första start 14.10) i eftermiddag. Åbytränaren Per Henriksen reser till hemlandet med en trio.</p>



<p>I gulddivisionen Per Rakkestads Minneslopp med 80.000 kronor i förstapris, möter Henriksens miljonär <strong>Make It Schermer</strong> (e. Propulsion) formstarke <strong>Sam The Man</strong> (e. Wishing Stone), som svarat för en lysande återkomst hos Erlend Rennesvik efter att ha varit borta i två år från tävlingsbanan.<br>Bronsdivisionen avgörs som en spårtrappa och där inleder Henriksens norske femåring <strong>Nencini</strong> (e. Southwind Frank) från spår åtta.Det tredje bidraget <strong>Jet Coktail</strong> (e. Coktail Jet) ställs mot Årjängsamatören Helena Edlunds <strong>Rocket Boy</strong> (e. Googoo Gaagaa) i ett montélopp.</p>



<p>Dessutom startar Lars-Gunnar Gustafssons <strong>Troll Winther</strong> (e. Ingbest) i ett kallblodslopp inom V75-spelet.</p>



<p><a href="https://www.travsport.no/travbaner/momarken-travbane/startlist/2025-07-26" target="_blank" rel="noreferrer noopener">Här är startlistorna till Momarkens tävlingar.</a></p>
