<p>Det är dags för V75 Champions på Åby denna vecka vilket innebär sju maffiga 15 hästarsfält! Klassen på tävlingarna är långt ifrån den högsta såhär veckan efter STL-finalerna, men det känner vi faktiskt att vi kan leva med och istället kan det öppna upp och göra omgången lite roligare ur ett strikt spelmässigt perspektiv.</p>
<p>Daniel Redén sänder tre hästar till Åby av varav två startar inom V75. Såväl <strong>Erin Zet</strong> (V75-1) som <strong>Bugatti Miles</strong> (V75-5) kommer sannolikt bli favoriter i sina lopp och vi kan inte förneka att de har passande uppgifter framför sig.</p>
<p>Därmed har han lagt en bra grund för Örjan Kihlström att dra det längsta strået i kuskmatchen.</p>
<p><a href="https://sulkysport.se/wp-content/uploads/2021/02/13v75.pdf" target="_blank" rel="noopener noreferrer">Här kan du ta del av lördagens tävlingar till Åby.</a></p>
<h2>Avd 1 – V75 Champions stolopp, 2.140 meter voltstart</h2>
<p><strong>Erin Zet</strong> stötte på <strong>Annie Flame</strong> i senaste starten och drog då det längsta strået efter att fått rygg på densamma. Med det loppet i kroppen lär Erin Zet vara ytterligare förbättrad och vi tycker hon känns som en riktigt vettig häst för klassen som klämt i med tre raka 1.11-avslutningar sista 800 meterna. Vinner <strong>Annie Flame</strong> starten gentemot formstarka Garca kan hon säkert bjuda upp till strid. <strong>Frequency Am</strong> såg jättefin ut i årsdebuten, men tvingas hon nu ge sig ut och runda i spåren mot dessa hästar kan det bli tuffare. <strong>Princess S.W.</strong> ska försöka plocka in 40 meter, men hon lyckades plocka in 60 meter i oktober så ska någon lyckas med den saken så är det hon. Därtill är stoet van att tävla med skor, men Peter Untersteiners stallform är sannerligen inget att hänga i granen för dagen&#8230;</p>
<h2>Avd 2 – Ungdomschampions &#8211; STL Ungdomslopp, 2.640 meter autostart</h2>
<p>Ett kul lopp där två hästar med påtaglig segeraptit står med de innersta startspåren. <strong>Hooper des Chasses </strong>har inlett sin sejour på svensk mark med tre segrar på de fyra första starterna. Senast öppnade han jättebra från spår fyra, frontade enkelt och såg verkligen stark ut hela vägen hem. Stressiga innerspår bakom bilen är dock något annat och här kan det bli tok. <strong>Bold Heuvelland </strong>har uppvisat ett brett register såhär långt på svensk mark och känns absolut inte missgynnad av den dryga distansen. <strong>Sedin U.S. </strong>har verkligen rätt kurva just nu, men vi oroar oss ändå lite för att han redan gör sin fjärde start för året. Det finns en liten risk att det kan sätta sig i benen. <strong>Incredible Wine </strong>och <strong>Åsanna Starline </strong>bedömer vi gå upp i klass denna gång.</p>
<h2>Avd 3 – V75 Champions, 2.140 meter voltstart</h2>
<p>Ett ruskigt lurigt lopp vid en första anblick. <strong>Flacco </strong>kan mycket väl komma att bli favorit med tre segrar i raden och en femteplats från ett klass I-försök. Han har tävlat i tuffa gäng även vid segrarna och är åtminstone en av segerkandidaterna. <strong>Bicc&#8217;s Avalon </strong>hade vi säkert landat på som tipsetta framåt veckoslutet om han stått bättre till, men nu handlar det om bakspår på tillägg. Skulle <strong>Geronimo Am</strong> lyckas hitta till tät och får löpa ut i den positionen är han inte alls så tokig. <strong>Quantum Roc</strong> står bra inne i loppet och var duktig tvåa bakom kapable Express A.P. senast på Jägersro. <strong>Timo Lane </strong>kan vara fältets mest kapabla häst, men det spelar ingen roll hur kapabel man än må vara i ljusa stunder om man inte får till det bättre än vad han har fått sista halvåret. Som sagt, vidöppet!</p>
<h2>Avd 4 – V75 Champions &#8211; Stolopp, 2.140 meter voltstart</h2>
<p>Inte mycket enklare här. <strong>Firstclass U.M. </strong>tävlade med punktering senast på Romme och gjorde med tanke på det ett starkt lopp som trea. Hon har varit duktig vid segrarna dessförinnan och lär avsluta bra om hon får draghjälp. <strong>Lilo Love </strong>har tagit ett par vintertriumfer från ledningen och är inte utan chans från den positionen här heller. <strong>Follow My Lead </strong>satt fast med sparade krafter senast på Sundbyholm. Lyckas Adrian Kolgjini sätta henne i en bra rygg och ha slagläge in mot upploppet kan vi absolut se henne hävda sig här. <strong>Gusto </strong>har gått jämnt och nyttigt varje gång. Hon var tvåa bakom Lorelei Marie senast som var betrodd i Diamantstofinalen i lördags. <strong>Nothing Like Malena </strong>har gått bra tidigare på svensk mark, men varit struken efter snäste starten. <strong>Tour Eiffel </strong>är speciell, men har en hög högstanivå.</p>
<h2>Avd 5 – V75 Champions &#8211; Stayerlopp, 3.140 meter voltstart</h2>
<p>Ett riktigt kul stayerlopp. <strong>Bugatti Miles </strong>övertygade på oss vid debutsegern i Daniel Redéns regi där han löste uppgiften till slut trots att han fick gå utvändigt ledaren. Från innerspår är han loppets troliga ledare och därifrån blir han svårpasserad. I skrivande stund är det sannolikt att vi hamnar på honom som spik i den här omgången. <strong>Dreamstone </strong>gör bra insatser varje gång och var knappt besegrad i onsdags. Skulle han komma ner bakom är han inte utan chans. <strong>Oracle Tile </strong>vann Klass I-finalen på annandag jul och var fin vid segern även gången efter på Åby. Han kan bli favorit, men att ta in 20 meter på Bugatti Miles blir inte enkelt. Johan Untersteiner återstiftar bekantskapen med <strong>Willmer Gel </strong>som gått strålande i Norrland efter regibyte.</p>
<h2>Avd 6 – V75 Champions, 2.140 meter voltstart</h2>
<p>Det är ingen vild gissning att <strong>Morotai Degato </strong>blir lördagens största favorit. Han har bra chans att ta ledningen från sitt springspår i lag med Erik Adielsson och kommer med bevisad form då han verkligen var tapper bakom Sweetman i klass I-finalen i lördags. Kanske är det bara täta starter som talar emot honom. Här finns det dock några spännande utmanare. <strong>Floris Baldwin </strong>går strålande bra varje gång och att jaga från 20 meter tillägg kan han nog leva med då det inte är lika meriterade hästar som står där framme som han är van att tävla mot. <strong>Upper Face </strong>var bra i klass I-finalen senast efter att gjort jobb själv. Går det undvika denna gång är han inte alls golvad. <strong>Deede Star </strong>var jättebra i comebacken, men klart sämre senast. Kanske är det så att han vill ha tätkänning och slippa spår på vägen för att fungera som bäst?</p>
<h2>Avd 7 – V75 Champions, 2.140 meter autostart</h2>
<p><strong>Broadway Sun </strong>har lyft flera snäpp i Per Henriksens regi och övertygat stort vid segrarna där han stövlat undan i ledningen. Det bör inte vara en nackdel för honom att det är ett halvvarv kortare distans denna gång och visst ska han räknas på nytt. <strong>Laradja Vrijthout </strong>rusade undan i ledningen i Sverigedebuten och såg inte ut att ha några planer på att stanna den dagen. Nu är det ett halvvarv längre distans, men han har spår invändig tom Broadway Sun. Det blir spännande att se vad man väljer för taktik med honom här. <strong>Hombre D. </strong>har haft svårt att få aktionen att stämma i de tre senaste starterna, men är annars bra nog för att utmana de bästa i det här loppet. <strong>Oxidizer </strong>vidhåller vi är rätt sort. Han avgjorde på ett riktigt fint vis senast på Axevalla, men nu är det dags för honom att leverera på lördagarna också. Det har han inte riktigt lyckats med i de tre tidigare försöken utan de har resulterat i en femteplats som bäst.</p>
