
<p class="has-drop-cap">1 </p>



<p>Han var länge landets meste champion och mannen bakom den ena segermaskinen efter den andra. 2012 avled Skellefteåprofilen Stig Lindmark i en ålder av 76 år.<br class="">Året innan kördes Stig Lindmarks Styrkeprov i Skellefteå för första gången och Stig fanns själv som plats som prisutdelare när blivande Elitloppsvinnaren <strong>Nahar </strong>(e. Love You) vann premiärupplagan i regi Per Lennartsson. Nahar vann även styrkeprovet 2013, ett par månader efter sin Elitloppsseger tillsammans med sin tränare Robert Bergh.</p>



<p>Stig Lindmark, som blev Skelleftetravets förste proffstränare 1958, vann 3.190 segrar som kusk och tog 64 banchampionat i Sverige! Detta fördelat på 35 gånger i Skellefteå, 23 gånger i Boden och sex gånger i Umeå. Redan 1972 blev han medlem i tusenklubben.<br class="">Bland Lindmarks stjärnhästar genom åren finns kallblodet <strong>Sabin</strong>, som vann 182 lopp, och varmblodet <strong>Dun Bunter</strong>, 113 segrar! Sådan var Stig Lindmark. En vinnare ut i fingerspetsarna.</p>



<p>Efter att tidigare avgjorts som ett flerklasslopp med grunddistansen 3.140 meter, så blev – med sommartravets intåg – Stig Lindmarks Styrkeprov ett gulddivisionsförsök över 2.640 meter med bilstart.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/04/globalbadman-617x333.jpg" alt="" class="wp-image-291057"/><figcaption class="wp-element-caption">Daniel Wäjerstens Global Badman. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Förra året blev det seger för <strong>Esprit Sisu</strong> (e. Ready Cash) och Daniel Wäjersten och Bergsåkertränaren har ett starkt kort även i årets upplaga, som bara lockat sju hästar. Wäjersten plockar ut <strong>Global Badman</strong> (e. Yield Boko) som främst ställs mot forne italienske Derbyvinnaren <strong>Chamant de Zack</strong> (e. Vivid Wise As) och 2020 års norske Derbytvåa <strong>Golden Dream M.E.</strong> (e. Buzzin Brian).</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/07/24v86.pdf">Här är startlistorna till Skellefteås STL-tävlingar ikväll.</a></p>



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



<p class="has-drop-cap">2 </p>



<p>Nästan sju miljoner kronor extra ligger i kvällens åttarättspott på V86 i Skellefteå  och räkna med en hel del Daniel Wäjersten i omgången, då han har hela nio hästar till start.</p>



<p>Wäjersten ligger tvåa i svenska tränarligan 2024 bakom Daniel Redén och samtidigt har Wäjersten nyligen bantat sin träningsrörelse från över 110 hästar till dagens 91 på träningslistan.</p>



<p>– Ett hyreskontrakt på en extra gård jag haft har gått ut och istället har jag ett mindre stall inne på Bergsåker med unghästar, berättade Daniel Wäjersten i ATG Live i måndags.</p>



<p><strong>––> Sulkysports spelstuga med viktiga punkter, spikar, drag och favoriter i fara på V86 publiceras som vanligt kl 12.00 idag.</strong></p>



<p>Vill du spela V86 hos Andelskungen tillsammans med Sulkysport finns följande alternativ:</p>



<p><a href="https://www.atg.se/andelskungen/spel/251721_V86_2024-07-24_25_3" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V86 – 15 andelar á 95 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206235_V86_2024-07-24_25_3" target="_blank" rel="noreferrer noopener">Sulkysport V86 UNIK exklusiv – 12 andelar á 150 kr/styck</a></p>



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



<p class="has-drop-cap">3 </p>



<p>Först Sören Nordin och Ulf Thoresen. Sedan Stig H Johansson – och <strong>Steggbest</strong>! Där har ni de fyra första som valdes in i svensknorska Hall of Fame, som hade premiär 2007. Steggbests avelsgärning för kallblodssporten var och är enorm. I eftermiddag hyllas han med sitt eget lopp på Skelleftetravet – där han är begravd vid mållinjen.</p>



<p>Totalt gjorde Steggbest 229 starter och vann 83 lopp. Han travade ihop otroliga nästan en kvarts miljon kronor på 1950-talet, 234.638 norska kronor för att vara exakt. Som snabbast travade Steggbest 1.29,3k innan han lade tävlingsskorna på hyllan efter tolvåringssäsongen.</p>



<p>Under 13 år i avelsboxen i Sverige betäckte Steggbest omkring 1.100 svenska ston, fick 690 avkommor som tillsammans vann 4.917 lopp och sprang in 29,1 miljoner kronor på 1970- och 1980-talet! Han lämnade segermaskiner som <strong>Ess Express</strong>, drottningen <strong>Sjunga Best</strong> och <strong>Andungen</strong> som vann över hundra lopp vardera.</p>



<p>Steggbest är genom hingstlinjen Trollfaks – Troll Jahn – Jahn Sjur farfars farfar till Järvsöfaks. Dessutom via mödernet Järvsö Anna – Vinjänta – Steggjänta är han mormors morfar, då han fick stoet Steggjänta tillsammans med Jäntungen. Steggbest finns ytterligare en gång i Järvsö Annas stamtavla.</p>



<p>Snabbaste vinnaren i Steggbests minneslopp är <strong>Hallsta Lotus</strong> (e. Järvsöfaks), som var nära att spräcka 1.20-vallen i loppet för 14 år sedan då han vann på 1.20,1.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/05/10b.w.sture2-617x333.jpg" alt="" class="wp-image-588400"/><figcaption class="wp-element-caption">B.W.Sture vann Speedrace tillsammans med Mats E Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Fjolårsvinnaren <strong>B.W.Sture</strong> (e. Moe Odin) travade 1.20,6 vid triumfen och han finns på plats ikväll för att försvara titeln. Precis som förra sommaren sitter Per Linderoth i sulkyn bakom den Jan-Olov Persson-tränade startblixten och hästen vann spårlottningen med bricka tre bakom bilen.</p>



<p>Snabbaste vinnarna av Steggbests Minne:</p>



<ul class="wp-block-list">
<li>2010 <strong>Hallsta Lotus</strong> (e. Järvsöfaks) – Ulf Ohlsson (Jan-Olov Persson) – 1.20,1a</li>



<li>2022 <strong>Stjärnblomster</strong> (e. B.W.Modde) – Mats E Djuse (Jan-Olov Persson) – 1.20,2a</li>



<li>2011 <strong>Pihlajan Aaroni</strong> (e. Villiari) – Akseli Lahtinen – 1.20,3a</li>



<li>2012<strong> Faksen J:r</strong> (e. Järvsöfaks) – Erik Adielsson (Jan-Olov Persson) – 1.20,4a</li>



<li>2018 <strong>Lome Brage</strong> (e. H.G.Balder) – Erik Adielsson (Jan-Olov Persson) – 1.20,4a</li>



<li>2013 <strong>Hallsta Lotus</strong> (e. Järvsöfaks) – Ulf Ohlsson (Jan-Olov Persson) – 1.20,5a</li>
</ul>



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



<p class="has-drop-cap">4 </p>



<p>Tre spännande, svenska hästar startar i Prix de Marmagne (€43.000) på Paris-banan Enghien (första start 14.23) i eftermiddag. Jörgen Westholms flerfaldige storloppsfinalist som unghäst, <strong>Ninepoints Lasse</strong> (e. Uncle Lasse), fick äntligen till det i sin sjätte start på fransk mark, då han plockade hem Prix Laura Flessel (€27.000) förra måndagen tillsammans med Alexandre Abrivard. Denne är anlitad även i dagens start, men sitter den här gången i sulkyn. Segern togs i monté.</p>



<p>Maria Törnqvist anlitar Yoann Lebourgeois bakom <strong>Bold Request</strong> (e. Bold Eagle), som slutade trea i Frankrikedebuten för två veckor sedan.</p>



<p>Comeback efter drygt tre månaders tävlingsuppehåll och debut i ny regi gör <strong>Sidney Celeber</strong> (e. Readly Express), som lämnade Tomas Malmqvist för Erik Bondo i april. Hästen var oplacerad i enda starten för Malmqvist.</p>



<p>Jarmo Niskanen tar ut <strong>Kai la Sha</strong> (e. Earl Simon) i fyraåringsloppet för ston, Prix de la Porte Didot (€40.000). Stoet körs av Mathieu Mottier.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/enghien-2024-07-24/">Här är startlistorna till Enghiens tävlingar.</a></p>



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



<p class="has-drop-cap">5 </p>



<p>Åbytränaren Maria Törnqvist fyller på sitt framgångsrika stall med ytterligare ett spännande nyförvärv i form av sjuårige <strong>Ture L.A.</strong> (e. Maharajah) som kommer från Halmstads tränare Johan Untersteiner, som haft valacken i sin vård sedan 2019.</p>



<p>Hos Johan blev det 13 segrar på 44 starter, varav två kom inom V75-spelet och totalt blev det 1.367.529 kronor insprunget.</p>



<p>Marias stall innehåller nu 64 hästar på träningslistan. Stallet har tagit 42 segrar på 157 starter och har 27 i segerprocent. Totalt har stallet kört in 4.186.130 kronor och har därmed knappt 200.000 kvar till fjolårets notering.</p>



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



<p class="has-drop-cap">6 </p>



<p>På lördag avgörs Per Rakkestads Minneslöp på Momarken över 1.640 meter autostart med 80.000 norska kronor till vinnaren. En av de åtta startande bakom bilens vingar är fyraårige Cabron (e. Caballion) som numera tränas och körs av Ole Johan Östre.<br>– Anledningen till att jag har hästen i träning är att familjen Severin Aarskog är på semester i Frankrike. Efter det här loppet ska han starta i ett fyraåringslopp på Biri nästa helg, berättar Ole Johan till tgn-no.</p>



<p>Och det är en optimistisk Östre som ser fram emot loppet på Momarken.</p>



<p>– Loppet på Axevalla i fredags kan vi glömma. Det gick i 1.15-fart första varvet och det var hopplöst att ta något till slut. Jag körde jobb med honom i går och han verkade pigg och fin. Från innerspår siktar vi på att leda hela vägen. Han möter bra hästar, men jag tror han kan gå en 1.10-tid. Det blir barfota fram och det har han inte gjort sedan segerloppet på Forus. Kanske sätter vi också på ett goggles-huvudlag.</p>



<p>Här är startfältet.</p>



<p><strong>Häst &#8211; kusk</strong></p>



<ol class="wp-block-list">
<li>Cabron &#8211; Ole Johan Östre</li>



<li>Mighty Boy &#8211; Vidar Hop</li>



<li>Ivanhoe &#8211; Ove Bakkevold Reime</li>



<li>Brake Cooling &#8211; Lars Anvar Kolle</li>



<li>Skate Trix &#8211; Frode Hamre</li>



<li>Goldstrike B.G. &#8211; Gunnar Austevoll</li>



<li>Charleston Volo &#8211; Åsbjörn Tengsareid</li>



<li>One Moment In Time &#8211; Olav Mikkelborg </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/2020/06/despotpower-617x333.jpg" alt="" class="wp-image-95912"/><figcaption class="wp-element-caption">Despot Power vid försöksvinst i E3. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">7 </p>



<p>Innan Skellefteås stordag drar igång blir det eftermiddagstrav med tio fyllda breddlopp i Örebro (första start 15.00).</p>



<p>En av hästarna som dyker upp är <strong>Despot Power</strong> (e. Readly Express), som vann försök och var tvåa i långa E3-finalen för fyra år sedan bakom Global Badman, som ju startar i Stig Lindmarks Styrkeprov ikväll.</p>



<p>Då tränades Despot Power av Kalmars Thomas Madsen, men sedan slutet av 2022 finns han i Solvallaamatören Nicklas Petterssons vård. Nicklas skötte under sin tid som hästskötare hos Stefan Hultman bland annat Kriterie-, Derby- och Elitloppsvinnaren From Above.</p>



<p>Despot Power är valack, men hann få en avkomma i dottern Despots Girl, som föddes förra året. Mamma till ettåringen är <strong>Olympia Bi </strong>(e. Andover Hall), som även lämnat First One In (724.582 kr) och He Is On (577.977 kr).</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/07/240724.pdf">Här är startlistorna till onsdagens tävlingar.</a></p>

Fokustema
Morgonsvepet
Läs senare
Vem är starkast i Stig Lindmarks Styrkeprov?
Stig Lindmarks Styrkeprov. Steggbests Minneslopp. Intressant nyförvärv till Maria Törnqvist. Tre spännande svenska starter i Frankrike.
Det är något av innehållet i Sju nyheter vid sju.
