
<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: 2 (One Memphis, Short In Cash)</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>En som visat att han gillar förutsättningarna är fjolårsvinnaren <strong>Borups Tornado</strong> (e. Maharajah), som plockade hem styrkeprovet förra året.<br>– <em>Borups Tornado vann det här loppet förra året tillsammans med Björn Goop efter att ha gått en imponerade sista långsida. Han var grymt bra då. För dagen tycker jag att hästen har smygform, han gick 1.10,7 sista varvet ute i spåren lite i skymundan senast. Han har tagit det loppet på rätt sätt</em>, säger hemmatränaren Ulf Stenströmer i banprogrammet till kvällens tävlingar.</p>



<p>Borups Tornado får en tuff uppgift att försvara segern i loppet. Bland annat står stallkamraterna <strong>Bold Knick</strong> (e. Bold Eagle) och <strong>Luca Vialli Boko</strong> (e.Ready Cash) för motståndet. Bold Knick hade sju raka segrar innan han gått på pumpen två gånger i rad.<br>– <em>Han har förlorat två gånger, dock utan att på något vis vara dålig. Han fick stryk av Chestnut i Lindesberg och nu senast blev han en aning ömfotad. Nu har vi dock sparat hov inför denna start. Jag tycker att uppgiften är intressant</em>, säger Stenströmer.</p>



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



<p class="has-drop-cap">2 13 lopp som kan bli 14 är programmet för Axevallas tävlingar ikväll. Anledningen är det heatlopp för hästar med högst 465.000 kronor på kontot, där åtta deltagare möts två gånger om med omvända startspår i det andra heatet. Skulle det bli två vinnare möts dessa i ett skiljeheat för 1.140 meter som avslutning på tävlingskvällen.</p>



<p>50.000 kronor är förstapriset i varje heat och slutvinnaren får 100.000 kronor extra, oavsett om denne vinner i två raka heat eller i skiljeheat. Dessa slantar vill Alessandro Gocciadoro lägga beslag på med <strong>Danao degli Dei </strong>(e. Mago d’Amore), som travade 1.10,4ak på Solvalla i Sverigedebuten i början av maj.<br>– <em>Danao degli Dei<strong> </strong>var fortsatt lite tung senast på Solänget. Han behövde det loppet var för att vara i bästa kondition till det här loppet. Ändå gick han 1.12,5 full väg så det var ingen dålig prestation. Hästen kan öppna väldigt snabbt och startspåren blev perfekta. Hästen är stor i kroppen och har varit lite överviktig så han har att ta av och kommer klara av två lopp samma dag</em>, säger Alessandro Gocciadoro.</p>



<p>Dagens höjdare är kanske annars ett treåringslopp för ston. Mattias Djuse-tränade <strong>Frustration</strong> (e. Fourth Domension) hade ett toppår som tvååring med andraplatser i Svensk Uppfödningslöpning och Svampen som toppnummer. Hon har pausat under våren och stod över långa E3, men nu startar hon med ett lopp i kroppen efter fem månaders uppehåll.</p>



<p>Motståndet går inte av för hackor med fyra finalister från E3 – <strong>Karma Mearas</strong>, <strong>Kitty Mearas</strong>, <strong>Käraste Sisu </strong>och <strong>Esperia Font</strong>, samtliga med Face Time Bourbon som far – och Guldstovinnaren <strong>Loke Sancy Diamond </strong>(e. Raja Mirchi) bland motståndarna.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/02/frustrationmadm230204adamstromstalltz-617x400.jpg" alt="" class="wp-image-407365"/><figcaption class="wp-element-caption">Frustration blir favorit i Treåringsstoet på Axevalla. Foto: Adam Ström/stalltz.se</figcaption></figure>



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



<p class="has-drop-cap">3 Bollnästränaren Thomas Lönn har plockat fram en hel del fina unghästar under tränarkarriären som hittills innehållit 940 segrar. Den största segern togs med <strong>Pau</strong> (e. Viking’s Way) i Breeders Crown-finalen för fyraåriga ston i Mantorp 2007. Pau var deluppfödd av Pieter Ahl och denne är både ägare uppfödare till en ny unghästtalang i Lönns stall. </p>



<p>Treåriga stoet <strong>Muscadelle</strong> (e. Flocki d’Aurcy) inledde tävlingskarriären på bästa sätt med två raka segrar i maj, innan det blev ett hack i skivan och hon fick strykas för halsinfektion från en tilltänkt start på Dannero midsommarveckan. Nu är hon redo igen och ett treåringslopp för ston är dagens uppgift på hemmabanan.</p>



<p>Bollnäs (start 12.20) lunchtävlingar har lockat en hel del spännande hästar och bland annat tar Jan Ove Olsen ut fyraåriga kallblodsstoet<strong> Farmens Riska</strong> (e. Norheim Faksen)</p>



<p>Dagens på förhand längsta segerrad har Sölve Bäcks<strong> Isas Dream Boy</strong> (e. Pojke Kronos), som efter att ha inlett med en seger på 33 starter nu ståtar med fyra raka (!) triumfer.</p>



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



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



<p class="has-drop-cap">4 I Cabourg (första start 18.58) ska Tomas Malmqvists montéess <strong>Intuition</strong> (e. Brillantissime) försöka bärga årets första seger i kvällens Prix Fandango (€57.000).<br>Det femåriga stoet har blivit diskvalificerad i tre av årets fyra starter, men möter överkomligt motstånd i kvällens lopp i jakt på segerchecken på 25.650 euro och lär bli favorit tillsammans med Adrien Lamy.</p>



<p>Till Cabourg sänds även Rikard Björlings <strong>Istra</strong> (e. Ulysse et Pagale) för start i Prix Honfleur Normandy Outlet (€23.000).<br>Det femåriga stoet kommer från seger i Chateaubriant och körs återigen av den dagens segerregissör Jean Charles Piton.</p>



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



<p class="has-drop-cap">5Traditionsenligt avgörs Einari Vidgrenin Muistoajo (€33.000) i finska Vieremä den tredje fredagen i juli.<br>Två svenskfödda fyraåringar utmanar tio finska dito och de blågula hoppen är Mauri Jaaras<strong> Millie de Veluwe</strong> (e. Villiam) samt Hannu-Pekka Korpis <strong>East Ward</strong> (e. Maharajah).<br>Favoritskapet lär <strong>Callela Nelson</strong> (e. Beer Summit) få bära efter att räknat hem den finska motsvarigheten till Sprintermästaren – Kuopio Stakes – tidigare under året.</p>



<p>Startlista Einari Vidgrenin Muistoajo<br>2.140 meter autostart, förstapris: 15.000 euro</p>



<ol class="wp-block-list">
<li>Carlos Combo (e. Muscle Mass) – Ville Pohjola (Antti Sangi)</li>



<li>Millie de Veluwe (e. Villiam) – Mauri Jaara</li>



<li>Massimo Hoist (e. Muscle Hill) – Santtu Raitala (Jukka Hakkarainen)</li>



<li>BWT Hurricane (e. Harper Blue Chip) – Tuomas Pakkanen (Jani Oinonen)</li>



<li>East Ward (e. Maharajah) – Jani Ruotsalainen (Hannu-Pekka Korpi)</li>



<li>Archibald (e. Lexus Font) – Jani Hartikainen (Petri Rojo)</li>



<li>Xenon Leader (e. Dream Vacation) – Niko Jokela (Petri Klemola)</li>



<li>Yoyo Avenger (e. Otello Pierji) – Eelis Murtola (Heikki Astikainen)</li>



<li>Ramsgate (e. Nuncio) – Victor Björkroth (Pekka Visuri)</li>



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



<li>Amazing Player (e. Quite Easy) – Jarmo Saarela (Irina Sarin)</li>



<li>Cupido Combo (e. Nuncio) – Antti Teivainen (Pekka Korpi)</li>
</ol>



<p>Ett fint fyraåringslopp avgörs även i danska Odense denna fredag, men då med lägre prispengar och färre deltagare.<br>Fjolårets danska Kriterievinnare tillika årets Jydsk Grand Prix-vinnare <strong>Howlingatthemoon</strong> (e. Cantab Hall) genrepar inför stundande derbykval och drabbar samman med <strong>Henrik Will</strong> (e. Great Challenger) som vann Klass I-försök i Vaggeryd den 28 juni på 1.11,8a/1.640 meter.</p>



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



<p class="has-drop-cap">6Björn Goop och Håkan Arvidsson fortsätter skörda framgångar på värmländsk mark.<br>Efter <strong>San Moteur</strong> (e. Panne de Moteur) segrat i Årjängs Stora Sprinterlopp följde nu duons <strong>The Eagle</strong> (e. Bold Eagle) upp med att vinna såväl försök som final av Westra Wermlands Sparbank med 25.000 respektive 50.000 kronor som segerpremier när Arvika avslutade sin säsong med lunchtävlingar under torsdagen.</p>



<p>Sjuåringen är halvbror med <strong>Buddha</strong> (e. Muscle Mass) 1.12,2am/1.433.513 kr och har <strong>Tiba Lavec</strong> (e. Ata Star L.) som mormor vilken även är mormors mor till San Moteur.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/10/hakanarvidsson-617x333.jpg" alt="" class="wp-image-226420"/><figcaption class="wp-element-caption">Håkan Arvidsson hämtar hederspriser kors och tvärs över landets travbanor. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<p class="has-drop-cap">7 Under gårdagen publicerades propositionerna för september på Svensk Travsports hemsida.<br>Den första höstmånaden innehåller givetvis Svenskt Travderby, men i år finns även SM-dagen på Åby med i kalendern då det är tidigarelagt på grund av UET-finaler på Solvalla andra helgen i oktober.</p>



<p>På just Åby avgörs faktiskt uttagningslopp till UET Grand Prix den nämnda tävlingsdagen den 30 september där tio av de tolv propositionerna är utskrivna med minst 100.000 kronor i förstapris.</p>



<p><a href="https://www.travsport.se/siteassets/relaterade-dokument/tavling/propositioner/propositioner-september-2023.pdf?936" target="_blank" rel="noreferrer noopener">Här kan du ta del av propositioner till tävlingsdagarna i september.</a></p>

Fokustema
Morgonsvepet
Läs senare
Vem står pall i Maraton?
Om den travfest som idag inleds på Axevalla, den traditionsenliga fyraåringskampen i Finland samt att kvalen till Europaderbyt inte avgörs på finalbanan Solvalla uppmärksammar vi bland annat i dagens morgonsvep.
