<p>Axevallas trippeltrav avslutas precis som vanligt med två V75-omgångar. Lördagens meny är klart trevlig både ur sport- som spelmässigt perspektiv och bortsett från <strong>Nymke Brigadoon</strong> (V75-3) så ser det ut som att de där klara favoriterna lyser med sin frånvaro.</p>
<p>Vi finner två lopp som sticker ut lite extra. Klass I-försöket (V75-4) innehåller Jeroen Engwerda och Rick Ebbinges italienskfödde segermaskin Zion Font som vunnit 17 av 20 starter och han möter Alessandro Gocciadoros Benedetto O.P. vars segeraptit inte heller går att anmärka på.<br />
Fyraåringen som kommer från just en Klass I-triumf har vunnit elva av 17 starter i karriären och visat att han tål att gå den tunga vägen vid behov.</p>
<p>Axevallalöpning (V75-7) ser sannolikt hemmastjärnan <strong>Handsome Brad</strong> i favoritposition, men konkurrens saknas på intet vis. Där kan inledningen på loppet bli avgörande, men visst ska Handsome Brad gälla som spetsfavorit från ett på Axevalla fördelaktigt innerspår.</p>
<p><a href="https://sulkysport.se/wp-content/uploads/2021/07/24v75.pdf" target="_blank" rel="noopener">Här kan du ta del av lördagens startlistor till Axevalla.</a></p>
<h2>Avd 1 – Silverdivisionen, 1.640 meter autostart</h2>
<p>Näst högsta klassen är lömsk denna vecka. <strong>Final Dream</strong> såg vädligt fin ut som fastlåst senast på Solvalla. Nu är det &#8221;raka spåret&#8221; och lyckas Linda Sedström hålla upp innerspåret med hästen vilket känns rimligt att tro så kan det tveklöst hålla hela vägen hem. <strong>Alcide Roc</strong> har blandat och gett i sina prestationer sedan han kom till Sverige. Just de här förutsättningarna med sprinterdistans och bil tycker vi är fördelaktiga för hans del. <strong>Deede Star</strong> var rejält på gång i våras och nu har han tagit ett steg till. Hästen har sett väldigt fräsch och fin ut vid segrarna i sommar och är ett givet bud. <strong>Gustafson</strong> är tillbaka på svensk mark och han är det med en svårbedömd formstatus, men faktum är att han mötte ganska tuffa hästar senast på Wolvega.</p>
<h2>Avd 2 – Klass II, 2.140 meter voltstart</h2>
<p>Ett förhållandevis klent Klass II-försök där det är svårt att peka ut chanslösa hästar. <strong>Majestic Up</strong> var tvåa bakom Timo Nurmos topphäst Calgary Games senast. Han tog verkligen max den dagen, men det var som sagt bakom en riktigt bra häst och gången innan övertygade han vid seger trots tufft lopp. <strong>Versace Broline</strong> kom aldrig riktigt till i loppet senast i Halmstad, men gick bra till slut som fyra och visade att han duger i Klass II-sammanhang.  <strong>Havbergs Classic</strong> var ute i ett tufft lopp senast i Halmstad och gjorde på intet vis bort sig. Skulle Johan Untersteiner lyckas hålla upp ledningen med hästen från innerspår i volten kan det hålla hela vägen.<strong> Yankee Dee</strong> fick för långt fram i Lindesberg, man avslutade bra i skymundan som trea. Hur klarar han av det snäva startspåret?</p>
<h2>Avd 3 – Diamantstoet, 2.140 meter voltstart</h2>
<p><strong>Nymke Brigadoon</strong> kan mycket väl bli lördagens största favorit och det tycker vi inte är så mycket att säga något om ifall så blir fallet. Hon vann den tunga vägen på Gotland och det enda orosmoln vi kan hitta är det faktum att hon nu gör sin tredje start inom loppet av 17 dagar. Hur hanterar hon den saken? För den som säker garderingsstreck så vimlar det av tänkbara hästar. Hans Crebas springare gör nästan aldrig ett dåligt lopp och såväl <strong>Dream Of MoneyD.E.</strong> som <strong>Keely Queen Er</strong> är intressanta objekt för den som vill gardera. Notera att den sistnämnda körs av Örjan Kihlström för första gången. <strong>Your Dreamlove</strong> är i dunderform och levererar slutvarv kring 1.11 gång efter gång. Ska man stå med bakspår på tillägg på någon bana så är det väl på Axevalla?</p>
<h2>Avd 4 – Stayerlopp, 3.140 meter voltstart</h2>
<p>Sannolikt blir Björn Goop favorit även här. <strong>Zurich As</strong> satt fast med rubbet sparat i finalloppet i Rättvik och vann därefter enkelt från ledningen i Lindesberg. Han ser jättefin ut för dagen och blir svårslagen om Goop kan forcera sin häst till tät på nytt. <strong>Reddington</strong> fick lägga flera speeder senast i Halmstad och var stor i nederlaget som tvåa (förvisso trea i mål) bakom Zarenne Fas. <strong>Maestro Crowe</strong> var &#8221;skrikhästen&#8221; i Harpers, men gick sig trött i ledningen den dagen. Han startade tätt inpå det loppet och det blev helt enkelt för tufft för hans del för att han skulle orka stå emot i Vaggeryd.<strong> Uncle Töll</strong> vann utan att imponera senast på Axevalla, men kan mycket i grunden.</p>
<h2>Avd 5 – Klass I, 2.140 meter autostart</h2>
<p><strong>Zion Font</strong> är en mycket spännande häst som vunnit 17 av 20 starter i karriären. En av förlusterna kom på Jägersro för två år sedan då han slutade fyra och det är faktiskt det enda lopp han har gjort på svensk mark. Det är väldigt svårt att bedöma hur bra den här hästen är av filmerna från Nederländerna och Belgien, men att han är startsnabb och tycks ha rätt &#8221;keps&#8221; har vi i alla fall kunnat lista ut. Öppnar han i samma fart som han gjorde från spår fem vid segern i Mons den 15 januari (det står felaktigt i de svenska listorna att loppet kördes i Wolvega) är han sannolikt den som anför fältet. <strong>Benedetto O.P.</strong> gjorde ett topplopp i Kalmar trots en tuff resa. Han har inte fått utdelning över full väg innan det, men då har han haft problem med resan till Finland samt en krånglande hov. Vi räknar med att han levererar på nytt. <strong>Axel Wind</strong> är ett tredje italienskt ämne av spännande karaktär. Fredrik B Larssons häst har har inlett spännande på svensk mark. <strong>Halo Am</strong> har inte startat sedan andraplatsen bakom Venture Capital i Klass II-finalen under Elitloppshelgen och är svårbedömd.</p>
<h2>Avd 6 – Bronsdivisionen, 2.140 meter autostart</h2>
<p><strong>Amornero Roc</strong> höll strålande från ledningen i bronsfinalen. Han fick se sig besegrad av Admiral As, men det var ingenting att säga något om. Vi tror att <strong>Vitro Diablo</strong> tar sig förbi <strong>Golden Guard</strong> direkt och då bör Mika Forss kunde trycka sig till tät i skede två med Amornero Roc. Blir så fallet är det givetvis hästen att slå för de övriga. <strong>Velten Versailles</strong> var inte alls sig lik i de tre sista starterna på svensk mark under fjolåret. Han har studsat tillbaka någorlunda i år, men vi är alltjämt tveksamma till om han är den &#8221;gamle Velten&#8221; på nytt. För den som söker en riktig kantboll kan <strong>Starbec&#8217;s A. to Z.</strong> vara ett kul bud. Han är ny i klassen, men gynnas bara av att möta bra hästar och starta i lopp där det kan bli tempo. Hästen levererar på en helt annan nivå när han tävlar barfota och vi kan inte tänka oss annat än att han kan kommer leverera ett jättebra upplopp här.</p>
<h2>Avd 7 – Gulddivisionen, 2.640 meter autostart</h2>
<p>En mycket spännande upplaga av Axevallalöpning. Hemmafavoriten<strong> Handsome Brad</strong> ska försöka hålla upp innerspåret och det kan faktiskt gå. Han var tapper som trea i Färjestads Jubileumslopp efter tufft lopp och ska gälla som favorit. <strong>Milligan&#8217;s School</strong> fick hopplöst långt fram senast i samma lopp och därtill en vid slutkurva precis som <strong>Milliondollarrhyme</strong>. Båda hästarna höll bra och visade att de har formen i helt rätt läge. Av de två tror vi klart mest på den förstnämnde då Milliondollarrhyme riskerar att hamna &#8221;åt råttorna&#8221; från spår åtta. <strong>Short In Cash</strong> var stor i nederlaget på utsidan om Cyber Lane i Halmstad, <strong>Ble du Gers</strong> gynnas inte av distansen på det sätt han gjorde förr om åren, men hanterar den väl på en platt tusenmetersbana. <strong>Antonio Trot</strong> har gått bra hela året, men hinner han verkligen fram från spår tolv på en snabb sommarbana?</p>
