
<p class="has-drop-cap">1 Ikväll körs Sveriges längsta travlopp på Axevalla (första start 17.20) då banan arrangerar Axevalla Maraton över 4.140 meter när Stochampionatshelgen drar igång. Trots att det bjuds på 150.000 kronor till vinnaren så tycks det ha skrämt bort en och annan deltagare för de är blott tio till antalet som gör upp.</p>



<p>2013 gjordes förutsättningarna om för loppet. 3.140 meter i grunddistans blev istället 4.140 meter.</p>



<p><strong>Här har vinnarna startat i Axevalla Maraton:</strong></p>



<ul class="wp-block-list">
<li>4.140 meter: 3 (One Memphis, Short In Cash, Luca Vialli Boko)</li>



<li>4.160 meter: 4 (Udo’s Oiler, Time Machine, Antonio Trot, Borups Tornado)</li>



<li>4.180 meter: 3 (Saston, Naglo’ del Nord, Pacific Face)</li>



<li>4.200 meter: 1 (Pacific Face)</li>
</ul>



<p>Ulf Stenströmer har tränat vinnaren de två senaste åren – <strong>Borups Tornado</strong> (e. Maharajah) och <strong>Luca Vialli Boko</strong> (e. Ready Cash) – och den sistnämnde finns med i årets upplaga för att försvara titeln. Ifjol vann han från startfållan, men nu är Luca Vialli Boko belastad med 20 meters tillägg i tiohästarsfältet.</p>



<p>– Loppet ser inte jättetufft ut, men å andra sidan har inte heller min häst rosat marknaden på slutet, det är ett frågetecken för formen. Senast i Vaggeryd fick han vandra utvändigt utan rygg och det var inte så passande. Här får vi se vad han hittar på, det kanske går att avancera tidigt i syfte att få överta ledningen. Kommer han dit, då tror jag på riktigt bra chans, säger Ulf Stenströmer i Axevallas banprogram.</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/05/reijoliljendahl-617x333.jpg" alt="" class="wp-image-450203"/><figcaption class="wp-element-caption">Reijo Liljendahl. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">2 Inledningskvällen på Stochampionatshelgen bjuder för första gången på Grand Slam 75-spel istället för V64 och bjuder på ett koppel spännande lopp.</p>



<p>Bland annat plockar Reijo Liljendahl ut sin nybakade E3-vinnare <strong>Screen Time Limit</strong> (e. Face Time Bourbon) i ett treåringslopp för ston. Stoet slog in två miljoner kronor vid vinsten i långa E3 och gör nu ett första besök på Stochampionatsbanan.<br>– Screen Time Limit var väldigt fin i E3. Hon fungerade dessutom perfekt barfota fram och det kommer att bli samma balans här. Hästen har tränat bra efter sin storseger och känns fortsatt uppåt, jag har inget att klaga på. Hon har ett bra utgångsläge och visade senast att hon kan öppna bra, säger Reijo Liljendahl i Axevallas banprogram.</p>



<p>Bland de sju motståndarna finns E3-finalisten och Breeders Course-finaltrean <strong>O’Hara Boko </strong>(e. Robert Bi), Svampenvinnaren <strong>Matchmadeinheaven</strong> (e. S.J.’s Caviar), som gör årsdebut.</p>



<p>Ett annat lopp av hög klass är femåringsloppet med 100.000 kronor till vinnaren. Alessandro Gocciadoro tar ut toppstoet <strong>Delicious Gar</strong> (e. Father Patrick), som inte kommer till dukat bord med motståndare som <strong>Dancer Brodde</strong> (e. Bold Eagle), <strong>Y.Not Diamant </strong>(e. Odessa Santana) och <strong>Following</strong> (e. Nuncio) bland motståndarna.</p>



<p>Axevalla har även premiär för ett riktigt sprinterlopp: 1.140 meter med autostart väntar i supersprintern för hästar upp till nästan miljonen intjänat.</p>



<p>36 lopp ska köras på Axevalla i helgen – <a href="https://sulkysport.se/wp-content/uploads/2024/07/stochampionatshelg2024.pdf">här är startlistorna till trippeltravet</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/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 under Elitloppshelgen. Nu ska han försvara titeln i Steggbests Minne. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">3 På onsdag är det Skellefteåtravet som står i fokus då de ska arrangera V86-tävlingarna som dessutom kryddas med en jackpott på   miljoner kronor. Och på programmet väntar en del spännande lopp.</p>



<p>Banas store profil, Stig Lindmark, har fått ett lopp uppkallat efter sig som heter Stig Lindmarks Styrkeprov och som körts sedan 2011. Då vann <strong>Nahar</strong> (e. Love You) med Per Lennartsson på 1.14,3/3.160 meter voltstart.</p>



<p>I fjol vann Daniel Wäjersten med <strong>Esprit Sisu</strong> (e. Ready Cash) på 1.13,2/2.640 meter autostart.</p>



<p>Årets startfält innehåller tyvärr bara sju hästar och duon som sticker ut är Daniel Wäjerstens <strong>Global Badman</strong> (e. Yield Boko) och Alessandro Gocciadoros <strong>Charmant de Zack</strong> (e. Vivid Wise As) som får Magnus A Djuse vid tömmarna.</p>



<p>Ett anrikt lopp som också ska avgöras under kvällen är Steggbests Minne. Kallblodsloppet avgjordes första gången 1976 och då gick segern till Stig Lindmark med <strong>Frejsab</strong> (e. Sabin). Segertiden blev 1.43,5/1.640 meter voltstart.</p>



<p>Förra året vann Jan-Olov Persson-tränade <strong>B.W.Sture </strong>(e. Moe Odin) på 1.20,6/1.640 meter autostart med Per Linderoth i vagnen. Duon finns med igen och vill förstås försvara titeln.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/07/24v86.pdf">Här är startlistorna till onsdagens V86-omgång i Skellefteå.</a></p>



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



<p class="has-drop-cap">4 Innan Axevallas trippeltrav drar igång på allvar väntar lunchtävlingar i Bollnäs (första start 12.20). Anders Eriksson har plockat fram ett riktigt ämne i treåriga stoet <strong>Ready to Run H.C.</strong> (e. Nuncio), som inlett tävlingskarriären på bästa sätt med två raka segrar.</p>



<p>Hon rekordsänkte med 2,3 sekunder till 1.14,9 över medeldistans med voltstart när hon tog andra segern i ett lopp i ST:s Unghästserie på Bergsåker senast. Då travade då strax över 1.12 sista kilometern med vassa 1.10 sista 400 och en sådan prestation inger förstås respekt. Nu blir det debut bakom startbilen i dagens treåringslopp för ston.</p>



<p>Bland motståndarna finns Daniel Redéns <strong>Mellby Maleficent</strong> (e. Propulsion) som avlade maiden i ett treåringslopp på Solvalla i senaste starten.</p>



<p>Redén plockar även ut en spännande debutant i nolloppet. Det handlar om treårige hingsten <strong>Suit Up Artist </strong>(e. Propulsion) som är lillebror till fjolårets Stoderbyvinnare i Norge, <strong>Cabaret Artist</strong> (e. Propulsion).</p>



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



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



<p class="has-drop-cap">5 Ett jubileum firades på franska banan Langon-Libourne igår. Då tog nämligen Jean-Paul Marmion som 3.000:e seger som tränare. Hästen som fixade milstolpen var fyraåriga stoet <strong>Kyria Bella</strong> (e. Brissac), som vann Prix Chateau Pont de Brion (€19.500) tillsammans med Antoine Wiels.</p>



<p>Marmon ligger just nu på 17:e plats i franska tränarligan med 42 segrar under 2024 och har 66 hästar i träning, samtliga ägs av honom själv.</p>



<p>Hans största stjärna genom åren är valacken <strong>General du Lupin</strong> (e. Lutin d’Isigny-Uvanita), 1.10,8ak*/€2.446.174, som startade 153 gånger (58-20-13). På fransk mark toppade General du Lupin i dubbla upplagor av Grand National du Trot. Han vann också Grupp II-loppen Prix de Washington (två gånger), Prix Chambon P, Prix des Ducs de Normandie, Prix du Bois de Vincennes, Prix d’Ete, Grand Prix du Conseil General Alpes Maritimes och Grand Prix du Sud-Ouest. Däremot var han utestängd i de största loppen i Frankrike eftersom han var valack.</p>



<p>General du Lupin avslutade karriären med två säsonger i Sverige hos Stefan Hultman, där han vann Guldbjörken, Malmloppet, Silverörnen, Mälarpriset och Midsommarloppet.</p>



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



<p class="has-drop-cap">6 Vaggeryd stod som värd för lunchloppen under torsdagen och där fick publiken på plats se en fin treåring i form av Sofia Aronsson-tränade <strong>Double Nature</strong> (e. Fourth Dimension) som tog sin tredje seger på fem starter. </p>



<p>Valacken serverades förvisso ett bra lopp i rygg på ledaren av André Eklundh men han avgjorde säkert sista biten på nya rekordet 1.14,4/2.148 meter autostart.<br>– En häst som jag kört två gånger och vunnit bägge. Det är en häst som jag var nyfiken på från början då jag var i kontakt med en avkomma till mamman Fanny Sisu. Han imponerade på mig och framtiden ser ljus ut, sade segerkusken.</p>



<p>Segern var värd 40.000 kronor och Sofia Aronssons talang har nu tjänat 132.500 kronor på fem starter. </p>



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



<p class="has-drop-cap">7 Under juni månad togs totalt 1.620 prover i Frankrike och de flesta hästarna testades efter lopp – 1.291 hästar – men det genomfördes fler kontroller.<br>Så här ser sammanställningen ut från den franska travsportens dopingkontroller i juni:</p>



<ul class="wp-block-list">
<li>24 hästar togs vid ankomst till travbanan innan de deltog i ett tävling. Dessa särskilda provtagningar anordnades på följande travbanor: Laval 5 juni, Vincennes 8 juni, Feurs 14 juni, Bordeaux 19 juni och Enghien 27 juni. Under var och en av dessa provtagningar tas prov på i allmänhet tre hästar. En särskild provtagning i större skala organiserades 22 juni i Marseille Vivaux och tio hästar testades.</li>



<li>De 14 hästar som deltog montéderbyt Prix du Président de la République på Vincennes och de 16 hästar som tävlade i Prix de Normandie 23 juni provtogs 48 timmar innan dessa tävlingarna i respektive träningsstall.</li>



<li>Fyra särskilda provtagningar för att söka efter bikarbonat anordnades i Vichy 3 och 26 juni, på Vincennes 18 juni och Enghien 27 juni. Under dessa provtagningar testades 60 hästar. Alla resultat var negativa.</li>



<li>109 hästar testades i samband med kvallopp.</li>



<li>76 hästar provtogs under träning på 19 olika anläggningar.</li>



<li>Tio prover togs som en del av den longitudinella övervakningen.</li>



<li>20 föl testades vid kontroller hos uppfödare på fyra olika anläggningar.</li>
</ul>



<p>Från och med 8 juli 2024 har bland dessa 1.620 prover som togs i juni har en (1) förbjuden substans i kategori I identifierats.</p>

Fokustema
Morgonsvepet
Läs senare
Axevalla inleder storloppshelgen
På fredagskvällen inleder Axevalla sitt trippeltrav med en GS75-omgång med ett gäng fina hästar. Vem är starkast i Maratonloppet? Och vem är snabbast i Supersprintern? Och kan B.W.Sture försvara titeln i Steggbests Mine?
Det och lite till läser ni om i ”Sju nyheter vid sju”
