
<p class="has-drop-cap wp-block-paragraph">12.640 meter med autostart är förutsättningarna i eftermiddagens gulddivisionslopp Axevallalöpning på Axevalla (första start 14.35). I potten ligger förutom förstapriset även en biljett till Åby Stora Pris med 1,5 miljoner kronor till vinnaren den 15 augusti.</p>



<p class="wp-block-paragraph">Den biljetten är hemmatränaren David Persson sugen på med sin stjärna <strong>Baron Tilly</strong> (e. Ready Cash), som efter två strålande insatser i maj – seger på 1.09,6ak och tvåa i Harper Hanovers lopp – har galopperat två gånger i rad.<br>– När han galopperade i Oslo Grand Prix (näst senast, reds. anm.) tyckte vi innan att han var i sitt absolut bästa skick så det var väldigt synd, men sånt är livet. Vi bytte bett och tog bort checkremmen efter Harper Hanovers men nu när han har galopperat två gånger så återgår vi till det bettet som han hade i de första loppen i år och så får han även ”käken” tillbaka på sig. Det kommer även att bli barfota runt om vilket är optimalt. Vi går in med en god känsla till loppet och felfri är han absolut med och gör upp om det, säger David Persson till Kanal75.</p>



<p class="wp-block-paragraph">Det har gått undan i Axevallalöpning genom åren och tre av de fyra senaste vinnarna har travat 1.11,5a eller snabbare, men frågan är hur fartglada kuskarna är med bara sex hästar i fältet?</p>



<p class="wp-block-paragraph">Det svenska rekordet innehas av <strong>Francesco Zet</strong> (e. Father Patrick) från vinsten i Svenskt Mästerskap på Åby i höstas, 1.11,1a/2.640 meter.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/07/18v85.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar på Axevalla.</a></p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/08/oracletilekm2-617x333.jpg" alt="" class="wp-image-335488"/><figcaption class="wp-element-caption">Oracle Tile och Kristian Malmin. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph"><strong>Snabbaste vinnarna i Axevallalöpning:</strong><br><em>År, häst (far) – Kusk (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2024 <strong>Oracle Tile</strong> (e. Ready Cash) – Magnus A Djuse (Kristian Malmin) – 1.11,2a</li>



<li>2025 <strong>Staro Mack Crowe</strong> (e. Bold Eagle) – Magnus A Djuse (Mattias Djuse) – 1.11,3a</li>



<li>2022 <strong>Milligan’s School</strong> (e. Yankee Glide) – Mats E Djuse (Stefan Melander) – 1.11,5a</li>



<li>2021 <strong>Milligan’s School</strong> (e. Yankee Glide) – Ulf Eriksson (Stefan Melander) – 1.11,6a</li>



<li>2017 <strong>Readly Express</strong> (e. Ready Cash) – Jorma Kontio (Timo Nurmos) – 1.11,7a</li>



<li>2016 <strong>Anna Mix</strong> (e. Ludo de Castelle) – Erik Adielsson (Sofia Aronsson) – 1.12,0a</li>



<li>2019 <strong>Milligan’s School</strong> (e. Yankee Glide) – Ulf Eriksson (Stefan Melander) – 1.12,2a</li>



<li>2018 <strong>Platon Face</strong> (e. Raja Mirchi) – Adrian Kolgjini (Lutfi Kolgjini) – 1.12,4a</li>



<li>2013 <strong>Beckham</strong> (e. Turbo Sund) – Åke Svanstedt – 1.12,5a</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">2Axevallas andra dag under trippeltravet bjuder på en intressant V85-omgång och Sulkysports expertpanel har plockat fram sina bästa spikförslag och skrällbud.</p>



<p class="wp-block-paragraph">Om sitt spikförslag säger en av experterna: <em>”Betrodda Unforgettable A.Y. har varit sanslöst bra hela året, men nu har hon dragit bakspår över sprinterdistans och kan inte utnyttja sin startsnabbhet. Det öppnar för en spetsvinnare, nämligen Robert Berghs <strong>M.T.Tomorrow&#8217;s Hope</strong> som inleder från spännande innerspår. Hon mötte stjärnston senast i Kalmar i form av Clarissa och S.G.Empress och gjorde det duktigt som trea. Nu är det läge för full pott!”</em></p>



<p class="wp-block-paragraph">Blir det medhåll från Robert Bergh? Nja, lite varningsflagg hissade tränaren i V65 Direkt angånde M.T.Tomorrows Hope:<br>– Hon är väldigt trampig innan bilen ska iväg och det är inte lätt för henne. Det finns lättare dagar att spetsa med henne. Kör jag felfritt kan jag ta vilken position som helst. Hon ser lite rejälare ut i musklerna och är laddad och fin, allt går på rätt sätt för henne, sade Robert Bergh.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v85-tips-ax-18-juli/" target="_blank" rel="noreferrer noopener">––> Här är experternas tips till Axevallas V85-omgång.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela andelsspel tillsammans med Sulkysports panel? Här finns olika alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/butik/simsalabim/V85_2026-07-18_8_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Simsalabim.</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/butik/69ansspel/V85_2026-07-18_8_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos 69:ans Spel &#038; Tobak.</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/butik/spelpoolen/V85_2026-07-18_8_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Spelpoolen.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/10/mackdeblary-617x411.jpg" alt="" class="wp-image-785628"/><figcaption class="wp-element-caption">Mack de Blary vinner för Théo Duvaldestin. Foto: Scoopdyga</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3Lördagens två höjdare på Paris-banan Enghien (första start 13.23) är treåringsloppet Prix Henri Cravoisier (€90.000) och Prix de Milan (€90.000) för fyraåringar.</p>



<p class="wp-block-paragraph">I treåringsloppet jagar Alexandre Buissons <strong>Nebraska de Ginier</strong> (e. Golden Brigde) sjunde raka segern. Hästen är obesegrad i årets sex starter.<br>Bland de ett år äldre hästarna utmanar Sebastien Guaratos italienska duo <strong>Golden Gio</strong> (e. Face Time Bourbon) och <strong>Ginger Gio</strong> (e. Tony Gio) franska mångmiljonärer som <strong>Mack de Blary</strong> (e. Face Time Bourbon) och <strong>Maitre Jacques</strong> (e. Rolling d’Heripre).</p>



<p class="wp-block-paragraph">I Prix de la Porte Montmartre (€59.000) med 26.550 euro i förstapris finns dagens svenskintressen. Emma-Sara Sjöbergs nioåring <strong>Red Hot Roadster</strong> (e. Red Hot Dynamite) är ute på franskt äventyr i Jörgen Westholms träning och gör fjärde starten där nere.<br>Efter att ha inlett med två ”nollor” på Vincennes tog han bronspengen i senaste starten i Reims blev det en bronspengar. Gabriele Gelormini sitter i vagnen den här gången och bland motståndarna finns venskfödde Mister Invictus (e. Ready Cash).</p>



<p class="wp-block-paragraph">I sulkyloppet Prix de l’Esplanade (€46.000) för fyraåriga ston plockar Sabine Kagebrant ut <strong>Mabellissime</strong> (e. Love You). Hästen väntar på första segern sedan hon ropades in av Stall Courant på Prix d’Amérique-auktionen i januari för 200.000 euro.</p>



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



<p class="wp-block-paragraph">I Montier-en-Der debuterar Marie Norberg egna treåringen <strong>Nisse Viking</strong> (e. Quaker Jet) i ett treåringslopp med 14.000 euro i total prissumma. På samma bana startar Ron Kuiper <strong>James Bay</strong> (e. Ganymede) i ett amatörlopp. Jörgen Westholm äger hästen.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/tangenbork-617x333.jpg" alt="" class="wp-image-450209"/><figcaption class="wp-element-caption">Tangen Bork och Tom Erik Solberg. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4Både 2023 och 2024 vann <strong>Tangen Bork</strong> (e. Bork Odin) norskt mästerskap för kallblod, men ifjol gjorde han bort sig med galopp när stallkamraten <strong>Brenne Borken</strong> (e. Bork Odin) segrade. När denne står på skadelistan är Tangen Bork det stora namnet i årets mästerskap, som avgörs på Sörlandet (första start 18.52) ikväll.</p>



<p class="wp-block-paragraph">Tangen Bork har kommit tillbaka i sommar efter uppehåll på grund av operation i framknäna förra hösten och vunnit båda sina starter. Då har det handlat om sprinterdistans, men nu ska nioåringen springa ett varv till. Det har han gjort vid åtta tillfällen tidigare och vunnit fyra av loppen.<br>Återstår om det blir en femte seger – och tredje NM-titel – från elftespår bakom bilen tillsammans med Tom Erik Solberg?</p>



<p class="wp-block-paragraph">På stosidan är <strong>Voje Lotta</strong> (e. Ängsborken) det stora namnet. Sexåringen ståtar med 24 segrar på 40 starter i karriären.</p>



<p class="wp-block-paragraph">Till snabbloppet Karsten T Gundersens äreslopp med 80.000 kronor till vinnaren över sprinterdistans skickar Hagmyrentränaren Jan Ove Olsen <strong>Mizai</strong> (e. Donato Hanover). Mizai ställs bland annat mot <strong>Stoletheshow</strong> (e. Dream Vacation), som gör comeback efter 3,5 månaders frånvaro, och <strong>Rome Pays Off</strong> (e. Muscle Hill). Båda hästarna är svenskägda och tränas av Frode Hamre.</p>



<p class="wp-block-paragraph"><a href="https://www.travsport.no/travbaner/sorlandets-travpark/startlist/2026-07-18" target="_blank" rel="noreferrer noopener">Här är startlistorna till Sörlandets tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">5Axevallas trippeltrav bjuder på 36 lopp och lika många vinnare. Den snabbaste kan vi redan utse trots att två tredjedelar av Stochampionatshelgen återstår. Veikko Haapakangas-tränade <strong>Mister Kabuki</strong> (e. Mister J.P.) tog hem supersprintern på 1.08,9a/1.140 meter tillsammans med Carl Johan Jepson.<br>– Han har haft ett litet uppehåll och vi har siktat lite mot det här loppet, det skulle passa honom bra, sade Veikko Haapakangas i vinnarcirkeln.</p>



<p class="wp-block-paragraph">Axevalla bjöd både på supersprint och Sveriges längsta travlopp under premiärkvällen. I Axevalla Maraton med grunddistans 4.140 meter blev det dött lopp mellan <strong>Bourbon Brodde</strong> (e. Traders) och <strong>Kaxig In</strong> (e. Ready Cash) – <a href="https://sulkysport.se/oskiljbara-over-fyra-varv/" target="_blank" rel="noreferrer noopener">läs mer här!</a></p>



<p class="wp-block-paragraph">Däremot är frågan om en annan hästs segertid i ett 1.100-lopp ikväll kommer att överleva som ”helgbästa”. I finska Mikkeli är det också är trav i dagarna tre och öppningskvällen tog svenskfödde <strong>In Love Mearas</strong> (e. Cantab Hall), som tränas av Anne Kangas, första segern för året när han travade 1.08,8a/1.100 meter.</p>



<p class="wp-block-paragraph">I morgon väntar Mikkelibanans största lopp för året, grupp I-klassade S:t Michel Ajo (€119.000) med 70.000 till vinnaren. Där travade <strong>Varenne</strong> (e. Waikiki Beach) 1.09,3 redan 2002 och svenskfödde <strong>Hierro Boko</strong> (e. From Above) har löpningsrekordet 1.08,3, noterat 2023. Ifjol segrade Daniel Redéns <strong>Double Deceiver</strong> (e. Cantab Hall) på 1.08,7a/1.609 meter med tränaren själv i vagnen.</p>



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



<p class="has-drop-cap wp-block-paragraph">6Under flera år har Solänget och Vaggeryd bjudit på breddloppsmästerskap med försök och final samma dag i breddloppssammanhang. Detta är tillbaka även i år på båda banorna och först ut är Solänget (första start 18.55) ikväll.</p>



<p class="wp-block-paragraph">I både försök och final bjuds 15.000 kronor i segerpremie så vid &#8221;jackpot&#8221; med seger i såväl försök som final kammar vinnaren hem 30.000 kronor och sköna startpoäng. Tre försökslopp avgörs från vilka de fem främsta tar sig till finalen där de startar från tre olika distanser.</p>



<p class="wp-block-paragraph">Vaggeryds breddloppsmästerskap avgörs den 22 augusti med 15.000 kronor i förstapris i försöken och dessutom vässade 30.000 kronor till vinnaren i finalen. Loppen är öppna för hästar upp till 800 startpoäng.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/07/260718.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/07/charliottas.h.fol-617x553.jpg" alt="" class="wp-image-875534"/><figcaption class="wp-element-caption">Charlotta S.H:s föl med Fourth Dimension som pappa. Foto Privat</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">7Diana Sten kan meddela att <strong>Charlotta S.H. </strong>(e. Zola Boko-Fast Allegro), 1.12,0ak/420.200 kr, har fått en dotter efter Fourth Dimension och det är hennes första avkomma. </p>



<p class="wp-block-paragraph">Mormor <strong>Fast Allegro</strong> (e. Fast Photo), 1.13,8ak/377.500 kr, har också lämnat <strong>Adde S.H.</strong> (e. Nu Pagadi), 1.10,3ak/2.843.534 kr. För egen del är Fast Allegro halvsyster med <strong>Finders Keepers</strong> (e. Keepitinthefamily), 1.10,3ak/7.443.522 kr, som bland annat vann Jämtlands Stora Pris, Årjängs Stora Sprinterlopp, Solvallas Jubileumspokal och Orebro Intn’l. </p>



<p class="wp-block-paragraph">Ni vet väl att ni kan maila in fölrapporter för fri publicering? Uppge mor, far och kön på fölet. Skriv också om ni bestämt vilken hingst stoet ska gå till i år och skicka gärna med en bild tagen på bredden.</p>



<p class="wp-block-paragraph"><a href="mailto:claes@sulkysport.se">Maila till Sulkysport</a></p>

Fokustema
Sju nyheter vid sju
Läs senare
Från Axevalla till Åby Stora
David Persson om hemmastjärnan. Snabbaste vinnarna i Axevallalöpning. Franska unghäststjärnor i Paris. Tangen Bork jagar tredje NM-guldet. Helgens snabbaste på Axevalla. Mästerskap – i breddlopp.
Detta och mer i lördagens ”Sju nyheter vid sju”.
Detta och mer i lördagens ”Sju nyheter vid sju”.
