
<p class="has-drop-cap">1<strong>Immortal Docs</strong> (e. Brillantissime) karriär har gått upp och ner, och upp och ner igen. Ikväll i Visby (första start 18.30) är Fredrik Wallins stjärna tillbaka på banan igen – för första gången sedan han slutade sexa i Prix d’Amérique den 25 januari.<br>– Immortal Doc har tränats ett tag efter operation, men han är inte alls vässad för något speciellt till idag. Jag vill se honom på banan, se att han är tillbaka och jag kan inte tänka mig att han ska kunna gå runt motståndarna, säger Fredrik Wallin.</p>



<p>Efter två starka säsonger som två- och treåring med närmare två miljoner kronor insprunget blev det ett svagt år som fyraåring. Tio starter (0-0-2) gav blott 289.140 kronor i utbyte.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/02/immortaldocfwh260125adamstromstalltz-617x384.jpg" alt="" class="wp-image-821559"/><figcaption class="wp-element-caption">Fredrik Wallins Immortal Doc. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Hade Immortal Doc gjort sitt på banan? Det hade han inte! Ifjol var han tillbaka med dunder och brak. Han inledde säsongen i Paris, kom hem till Sverige och vann stayerlopp både på Bjerke och i Halmstad på sommaren innan fullträffen kom genom segern i Åby Stora Pris. En ny vinter i Paris väntade och 2025 avslutades med andraplatsen bakom Epic Kronos i Prix Tenor de Baune. 15 starter, tre segrar och över fyra miljoner kronor insprunget blev facit för succéåret.</p>



<p>2026 började med tredjeplats i Prix de Belgique, vilket kvalificerade honom för det stora slaget på Vincennes två veckor senare. Där, i världens tuffaste travlopp, spurtade Immortal Doc strålande till sjätteplatsen tillsammans med Björn Goop.</p>



<p>Immortal Doc hade bara fyra hästar framför sig när det gäller vinstrikaste svensktränade travare förra året.</p>



<p><strong>Svensktränade och svenskfödda hästar över fyra miljoner 2025</strong>:<br><em>Häst (kön, ålder, far) – Prispengar (kr) – Tränare</em></p>



<ul class="wp-block-list">
<li><strong>Dream Mine</strong> (h 4 år e. Maharajah) – 9.179.500 – Jörgen Westholm</li>



<li><strong>Don Fanucci Zet</strong> (h 9 år e. Hard Livin) – 7.305.914 – Daniel Redén</li>



<li><strong>La Yuca</strong> (s 4 år e. Face Time Bourbon) – 5.492.858 – Daniel Redén</li>



<li><strong>Mellby Jinx</strong> (7 år e. Ready Cash) – 4.337.910 – Daniel Wäjersten</li>



<li><strong>Immortal Doc</strong> (h 5 år e. Brillantissime) – 4.032.555 – Fredrik Wallin</li>



<li><strong>S.G.Empress</strong> (s 4 år e. Readly Express) – 4.012.000 – Roger Walmann</li>
</ul>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/07/29v86.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Visbys tävlingar ikväll.</a></p>



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



<p class="has-drop-cap">2Gotlandslöpningen är Visbytravets största lopp under säsongen och i historiken bakom loppet sticker ett namn ut: Stig H Johansson!<br>Sedan 1987 har loppet körts och Stig H inledde med att vinna de fem första upplagorna, först med <strong>Bosse Boss </strong>(e. Wind Boss) och sedan fyra gånger i rad med Gotlandsfödde stjärnan <strong>Piper Cub</strong> (e. Tibur).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/02/pipercubmal-617x333.jpg" alt="" class="wp-image-140365"/><figcaption class="wp-element-caption">Piper Cub och Stig H Johansson plockade hem Prix de Paris 1990. Foto Stefan Melander/Stalltz.se</figcaption></figure>



<p>Därefter vann Stig H Johansson loppet ytterligare nio gånger som tränare: <strong>Digger Crown </strong>(e. Lindy´s Crown) vann tre gånger, <strong>Storstadsbusen</strong> (e. Ata Star L.) tog två segrar medan <strong>Clipton</strong> (e. Brandy Hanover), <strong>Au Revoir H.</strong> (e. Nuclear Kosmos), <strong>Victory Tilly </strong>(e. Quick Pay) och <strong>Perfectly Enough</strong> (e. Express It) triumferat en gång vardera.</p>



<p>14 tränarsegrar i Gotlandslöpningen alltså, men på senare år har Daniel Redén tagit över rollen. Han tränat vinnaren sex av de elva senaste gångerna! Bland dessa finns tidernas snabbaste vinnare <strong>Love Matters</strong> (e. Explosive Matter), som slog till på 1.10,0 över medeldistans med bilstart för sju år sedan.</p>



<p><strong>Snabbaste vinnarna av Gotlandslöpningen</strong><br><em>År, vinnare (far) – Kusk (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2018 <strong>Love Matters</strong> (e. Explosive Matter) – Örjan Kihlström (Daniel Redén) 1.10,0</li>



<li>2021 <strong>Zaccaria </strong>Bar (e. Ready Cash) – Mika Forss (Alessandro Gocciadoro) 1.10,8</li>



<li>2025 <strong>Jerka Sting</strong> (e. Readly Express) – Claes Sjöström – 1.11,1a</li>



<li>2024 <strong>Castor The Star</strong> (e. Maharajah) – Mats E Djuse (Jörgen Westholm) – 1.11,3a</li>



<li>2017 <strong>Whitehouse Express</strong> (e. Yankee Glide) – Örjan Kihlström (Daniel Redén) 1.11,4</li>



<li>2022 <strong>Missle Hill</strong> (e. Muscle Hill) – Örjan Kihlström (Daniel Redén) 1.11,4</li>



<li>2015 <strong>Traveling Man</strong> (e. Supergill) – Ulf Ohlsson (Daniel Redén) 1.11,7</li>



<li>2019 <strong>Perfect Spirit</strong> (e. Andover Hall) – Örjan Kihlström (Daniel Redén) 1.11,7</li>



<li>2023 <strong>Missle Hill</strong> (e. Muscle Hill) – Örjan Kihlström (Daniel Redén) 1.11,7</li>
</ul>



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



<p class="has-drop-cap">3Årets upplaga av Gotlandslöpningen med 150.000 kronor till vinnaren är en spårtrappa för silver- och gulddivisionshästar och åtta hästar tar plats bakom startbilen.</p>



<p>En av dessa är titelförsvararen <strong>Jerka Sting</strong> (e. Readly Express) med 13-faldige championkusken i Visby, Claes Sjöström, i vagnen. Det var Sjöströms första inteckning som kusk och tränare i Gotlandsbanans största lopp och togs efter en rykande avslutning i fjärdespår sista 400 meterna.<br>Med ett litet fält – sju motståndare – kanske Sjöström kan servera sin stjärna en liknande resa igen och blir det seger eller andraplats för Jerka Sting kan han efter kvällen titulera sig trippelmiljonär.</p>



<p>Är Jerka Sting en vinnare även ikväll? Sulkysports expertpanel levererar sina bästa spikar och roliga skrällar till kvällens V86-omgång vid lunchtid idag.</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/V86_2026-07-29_28_3" target="_blank" rel="noreferrer noopener">Här finns andelar till V86 hos Simsalabim.</a></p>



<p><a href="https://www.atg.se/butik/69ansspel/V86_2026-07-29_28_3" target="_blank" rel="noreferrer noopener">Här finns andelar till V86 hos 69:ans Spel &#038; Tobak.</a></p>



<p><a href="https://www.atg.se/butik/spelpoolen/V86_2026-07-29_28_3" target="_blank" rel="noreferrer noopener">Här finns andelar till V86 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/2024/07/charron-617x347.jpg" alt="" class="wp-image-605632"/><figcaption class="wp-element-caption">Charron. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">4I lördags tog han hem norskt mästerskap på Biri för andra året i rad. Nu kvitterar Geir Vegard Gundersen-tränade <strong>Charron</strong> (e. Code Bon) ut den sjätte biljetten till Åby Stora Pris den 15 augusti med 1,5 miljoner kronor till vinnaren över 3.140 meter med autostart.</p>



<p>Charron följde upp starten i Elitloppet (utslagen i försöket) med galopper i två raka starter hemma i Norge innan han i lördags visade vem som är bäst och blev norsk mästare. <br>– Han vann norskt mästerskap på väldigt fint sätt i helgen och har gjort flera bra insatser i år. Just nu är jag nöjd med startfältet och det är sex platser kvar att fylla, sade Åbys chef Jon Walter Pedersen.</p>



<p>2024 års norske Derbyvinnare Charron har gjort 38 starter och vunnit 14 av dessa.</p>



<p><strong>Inbjudna till Åby Stora Pris 2026</strong><br><em>Häst (far) – Tränare</em></p>



<ul class="wp-block-list">
<li><strong>Charron</strong> (e. Code Bon) – Geir Vegard Gundersen</li>



<li><strong>Francesco Zet</strong> (e. Father Patrick) – Daniel Redén</li>



<li><strong>Get A Wish</strong> (e. Wishing Stone)– Robert Bergh</li>



<li><strong>Ibiki de Houelle</strong> (e. Love You) – Kevin Leblanc</li>



<li><strong>Macahan</strong> (e. Maharajah) – Maria Törnqvist</li>



<li><strong>Phantom Express</strong> (e. Readly Express) – Joakim Elfving</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/2023/01/readlylaveccsm-617x333.jpg" alt="" class="wp-image-400685"/><figcaption class="wp-element-caption">Readly Lavec vid tidigare seger i Cagnes-sur-Mer. Foto Gerard Forni.</figcaption></figure>



<p class="has-drop-cap">5Paris-banan Enghien (första start 19.00) är huvudbanan på fransk mark idag och det blir en hel del blågult till start. Efter seger i årsdebuten i Visby i juni sände Oskar J Andersson <strong>Readly Lavec</strong> (e. Bird Parker) på en ny Frankriketurné. Återkomsten slutade med fjärdeplatsen i Prix de l&#8217;Opera (€68.000) för tre veckor sedan.</p>



<p>Ikväll väntar ny start, i Prix du Parc des Princes (€75.000), över 2.875 meter med 33.750 euro till vinnaren. Benjamin Rochard sitter i vagnen och Readly Lavec har sällskap av ytterligare en svenskfödd travare i <strong>Nelson Greenwood</strong> (e. Tobin Kronos).</p>



<p>Tolv av 16 hästar är ”icke-franska” i bilstartsloppet Prix de Grigny (€46.000) över 2.150 meter. Sex italienska, fem svenska och en norskfödd ställs mot fyra fransoser i kamp om 20.700 euro i förstapris.<br>Markus B Svedberg mönstrar <strong>Michigan Bro</strong> (e. S.J.’s Caviar), medan Jimmy Dahlman tar ut sin stjärna<strong> Oh Cean</strong> (e. Friction). Båda svensktränade hästarna inleder från bakspår.<br>Övriga blågula i loppet är <strong>Global Duty</strong> (e. Trixton), <strong>Pure Steel</strong> (e. Bird Parker) och <strong>Beenthereseenthat</strong> (e. Broadway Hall).</p>



<p><a href="https://www.letrot.com/courses/programme/2026-07-29/7502" target="_blank" rel="noreferrer noopener">Här är startlistorna till Enghiens tävlingar.</a></p>



<p>Jarmo Niskanen har bara 21 starter som tränare hittills i år (en seger) och i Amiens (första start 15.50) provar han med treårige <strong>Ninos</strong> (e. Earl Simon), som blivit diskvalificerad i livets två första starter. Ägaren Joan Melis Macias sitter i vagnen.</p>



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



<p class="has-drop-cap">6Finlands största travfest står för dörren. Tammerforsbanan Teivo kommer att invaderas av publik i helgen när Kungstravet avgörs i tre avdelningar. 2.100 meter autostart på lördagen följs av 1.609 meter och avslutningen över 3.100 meter på söndagen. Det finska kallblod med bästa sammanlagda tid blir travkung!</p>



<p>Björn Goop har firat triumfer med finska kallblod från stortränaren Antti Ojanperäs stall. Han vann Erkon Pokaali på Vermo med <strong>Stallone</strong> (e. Frans) och följde upp med vinst bakom <strong>Pro</strong> (e. Provinssi) i Elitkampen på Solvalla.<br>Nu stiftar han bekantskap med en tredje häst från Ojanperäs stall, sjuårige <strong>Vänrikki</strong> (e. Välähdys), som vunnit 16 av 44 starter.</p>



<p>Jorma Kontio är anlitad bakom veteranen <strong>Evartti</strong> (e. K.M.Nopsa), också från Ojanperäs stall. 15-årige Evartti tog tre raka segrar i Kungstravet 2020-2022, medan Jorma själv vann alla tre avdelningarna i Kungstravet 2015 bakom <strong>Jokivarren Kunkku</strong> (e. Turo).</p>



<p>De senaste två årens travkung <strong>V.G.Voitto</strong> (e. Viesker) saknas i årets upplaga. </p>



<p>De åtta vinstrikaste hästarna får framspår i de första två avdelningarna och Vänrikki har bricka sju i medeldistansloppet och två i sprinterloppet.</p>



<p><strong>Startlista Kungstravet, Tammerfors</strong><br>2.100 meter autostart (1.609 meter avd 2)<br><em>Spår (spår avd 2) Häst – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>(8) <strong>Lumettaja</strong> – Terho Rautiainen</li>



<li>(7) <strong>Pro</strong> – Hannu Torvinen (Antti Ojanperä)</li>



<li>(6) <strong>Uljas Suomalainen</strong> – Tapio Perttunen</li>



<li>(5) <strong>Wertti</strong> – Jani Ruotsalainen</li>



<li>(4) <strong>Alarik Huikea</strong> – Santtu Raitala (Antti Ojanperä)</li>



<li>(3) <strong>Evartti</strong> – Jorma Kontio (Antti Ojanperä)</li>



<li>(2) <strong>Vänrikki</strong> – Björn Goop (Antti Ojanperä)</li>



<li>(1) <strong>Enon Vilppi</strong> – Jari Autio (Katja Luoma)</li>



<li>(12) <strong>Herra Heinämies</strong> – Jukka Torvinen (Antti Ojanperä)</li>



<li>(11) <strong>Vieskoff</strong> – Patri Filatoff (Jyrki Filatoff)</li>



<li>(10) <strong>Alpertto</strong> – Henri Bollström (Jarmo Leinonen)</li>



<li>(9) <strong>Soketti</strong> – Tino Keväänranta (Hannu Isotalo)</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/05/1beartime2-617x333.jpg" alt="" class="wp-image-856471"/><figcaption class="wp-element-caption">Beartime och Helena Edlund. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">7Årjängsamatören Helena Edlunds kämpe <strong>Beartime</strong> (e. Pastor Stephen) har en härlig milstolpe i sikte. Det fattas nämligen bara drygt 40.000 kronor för att hästen ska bli femfaldig miljonär i svenska kronor.<br>På lördag åker Edlund över gränsen till Momarken med sin elvaåring, som startar i Steinlagers Åreslopp över sprinterdistans. Beartime har goda minnen från loppet. Både 2022 och 2024 blev det nämligen seger med Carl Johan Jepson. </p>



<p>Den här gången körs Beartime av Steinlagers tränare och kusk Per Oleg Midtfjeld! <strong>Steinlager</strong> (e. Good As Gold) hade en strålande tävlingskarriär, där 88 starter (35–15–12) inbringade över 13,2 miljoner kronor. Vid segern i Elitloppsfinalen 2005 satte han sitt rekord 1.10,0a/1.609 meter.<br>2005 var Steinlagers främsta år. Då vann han de största loppen för äldre i de tre skandinaviska länderna genom att förutom Elitloppet även plocka hem Copenhagen Cup och Oslo Grand Prix. Steinlager vann även Åby Stora Pris 2004 och tog dubbla triumfer i Årjängs Stora Sprinterlopp för att nämna några ytterligare segrar.</p>



<p><strong>Startlista Steinlagers Äreslopp, Momarken lördag</strong><br>1.640 meter autostart, förstapris 100.000 NOK<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li><strong>Type A. </strong>(e. Southwind Frank) – Cato Antonsen</li>



<li><strong>Coral Coger</strong> (e. Ken Warkentin) – Olav Mikkelborg</li>



<li><strong>Nelson Daytona</strong> (e. Father Patrick) – Tom Erik Solberg (Kjetil Helgestad)</li>



<li><strong>Mighty Boy</strong> (e. El Diablo B.R.) – Per Vetle Kals (Marielle Bråthen)</li>



<li><strong>Beartime</strong> (e. Pastor Stephen) – Per Oleg Midtfjeld (Helena Edlund)</li>



<li><strong>Life On The Bluf</strong> (e. Walner) – Magnus Teien Gundersen (Anders Lundström Wolden)</li>



<li><strong>Always On Time</strong> (e. Revenue) – Svein Ove Wassberg (Kjetil Helgestad)</li>



<li><strong>Wishful Order</strong> (e. Muscle Hill) – Eirik Höitomt (Kjetil Helgestad)</li>
</ol>

Fokustema
Sju nyheter vid sju
Läs senare
Från Prix d’Amérique till Visby
Gör comeback efter sjätteplatsen i Prix d’Amérique. Stig H och Redén Gotlandslöpningens kungar. Ny häst till Åby Stora Pris. Goops debut i Kungstravet. Svensk kan bli femfaldig miljonär.
Detta och mer i onsdagens ”Sju nyheter vid sju”.
Detta och mer i onsdagens ”Sju nyheter vid sju”.
