<p><span class="anfang">Å</span>by står som värd för veckans V75-omgång där det är lite blandad klass på loppen. Fälten är förvisso fulla, men det var faktiskt ganska tunt anmält och det finns lite väl många hästar med begränsad mängd startpoäng i flera av loppen för att den där riktiga jämnheten ska infinna sig.</p>
<div class="factbox right ">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									BANFAKTA ÅBY								</h3>
<div class="content">
<p><strong>Längd: </strong>1.000 m<br /><strong>Bredd: </strong>22,3 m (2.140 m), 22,3 m (1.640 m)<br /><strong>Upplopp: </strong>180 m<br /><strong>Open stretch: </strong>Ja, dubbla<br /><strong>Vinklad startbilsvinge: </strong>Nej</p>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
<p>Timo Nurmos <strong>Amalencius B.B.</strong> (V75-5) tror vi kommer bli omgångens största favorit. Han gör debut i Bronsdivisionen, men matchade och besegrade några av kulltopparna ifjol. Inget tyder på att han ska få svårt att bära de 330.000 kronor han sprungit på sig i årets inledande Klass I-triumfer.<br />
Mycket talar för att även vi kommer infoga oss i ledet och spika honom medan vår andra spontana tanke av singelstreck kan vara mer originellt. <strong>Magical Mile</strong> (V75-4) är nämligen anmäld barfota runt om och har verkligen samlat ihop till en seger efter tre andraplatser på de fyra senaste starterna.</p>
<p><a href="https://sulkysport.se/wp-content/uploads/2022/03/12v75.pdf" target="_blank" rel="noopener">Här kan du ta del av lördagens startlistor till tävlingarna på Åby.</a></p>
<h2>Avd 1 – Stoeliten, 1.640 meter autostart</h2>
<p><strong>Global Brilliance</strong> har fått rena drömloppet i sitt första framträdande som femåring. Från innerspår är det spetschans på optimal balans och tränare David Persson infomerade oss i föregående vecka om ett vettigt banjobb inne på Axevalla även om stoet är lömskt och sällan gör mer än vad som krävs när hon springer ensam. <strong>Red Lady Express</strong> gör i sin tur första starten som fyraåring och den sker alltså mot den äldre stoeliten. Hade det varit slutet av säsongen så hade det berört oss föga, men normalt sett ska inte ett svenskt, fyraårigt sto matcha elitdamerna i början av året. <strong>Dear Friend</strong> har haft en okej vinter på Vincennes med en andraplats som bäst på tre starter. Vi utgår ifrån att Johan Untersteiner försöker utnyttja hennes startsnabbhet och ska någon komma förbi Global Brilliance så lär det vara Dear Friend som därtill kan få lite nytändning nu när hon kommer tillbaka och tävlar på en platt tusenmetersoval. <strong>Carna Sensei</strong> vann V75 Champions på samma bana i början av februari, men det var i klart svagare omgivning. Hon är i vilket fall en duglig häst även i sådana här sällskap och är åtminstone en outsider.</p>
<h2>Avd 2 – Klass I, 2.640 meter autostart</h2>
<p><strong>Digital Indy</strong> övertygade senast på Jägersro där han avslutade 1.10,5 sista 800 meterna framme i ledningen och gick i mål med full spänst. Han har bara haft innerspår en gång tidigare bakom bilen och lyckades faktiskt fronta. <strong>Borups Tornado</strong> fick traska som förstahäst i andraspår i Klass I-försöket på Axevalla – om än på behörigt avstånd från ledaren – och det såg ut som det blev för besvärligt rent moraliskt. Han laddar snabbt om över en distans som normalt sett faller honom i smaken och nu återstår att se om körande Ulf Ohlsson vågar fullfölja och nyttja den jänkarvagn man hade planlagt att hästen skulle tävla med senast, men valde bort efter värmningen. <strong>Rossi Garline</strong> vann ett långlopp från dödens så nyligen som i fredags på Charlottenlund. Det höll givetvis inte samma klass som detta, men hästen såg stark ut över målgången. <strong>Hemisphere</strong> har tre segrar och två tredjeplatser på sex försök över lång distans så styrka saknas inte i den här ständigt påpassade amerikanaren. <strong>Equal To None</strong> är härdad inom STL i vinter och Lucifer Sam var rejäl vid segern senast på Axevalla där han besegrade tappre <strong>Explosive Peak</strong>.</p>
<h2>Avd 3 – Gulddivisionen, 1.640 meter autostart</h2>
<p>En kul, men lömsk Gulddivision. <strong>Stoletheshow</strong> såg &#8221;hela världen&#8221; i Sundsvall där han spurtade till sig andraplatsen i Bergsåker Winter Trot på ett sätt som det skrek nästa gång om. Med rygg på startsnabba hästar har han möjlighet att hamna långt fram i fältet direkt och sitta bra till när det drar ihop sig. Spetskampen är oviss. <strong>Disco Volante</strong> vek sig från tät på Axevalla och har raske <strong>Tycoon Conway Hall</strong> på insidan samt likaledes snabbe <strong>Harran Boko</strong> på utsidan. Normalt sett är Disco Volante spetsfavorit, men då han blandar och ger på alla möjliga plan för dagen så känns inget givet kring nioåringen. <strong>Upstate Face</strong> växte in i den absoluta eliten på ett strålande sätt ifjol och känns som framtidsnamnet i loppet, men frågan är hur han hamnar till positionsmässigt från spår sju?</p>
<h2>Avd 4 – Diamantstoet, 2.140 meter voltstart</h2>
<p>Det var tuffa papper för stackars <strong>Magical Mile</strong> senast i Örebro där hon kutade 1.12,3 sista varvet och gjorde en topprestation, men likväl var chanslös att nå ifatt Denali Doc. Nu är våren här och får David Persson ytterligare en växel i stoet på barfota runt om vilket han anmält i utgångsläget så kan hon vara oslagbar. <strong>Donna</strong> såg ut att vara nära att fela redan från start i lördags och det verkade aldrig riktigt som hon hittade stilen därefter utan galoppen utvändigt ledaren 1.200 kvar kom föga oväntat. Nu återgår man till den gamla balansen med skor runt om, men hon är hårt anmäld på pengarna från sitt tillägg. <strong>Gabi Goes to Paris</strong> var fin vid spetssegern i Eskilstuna och satt fast med rubbet sparat gången efter. <strong>Diversity Pellini</strong> och<strong> Lisa Liseux</strong> står bra inne på tillägg och känns spontant också som tidiga kort liksom Benita Winner som nu får sitt elddop.</p>
<h2>Avd 5 – Bronsdivisionen, 2.140 meter autostart</h2>
<p>Här möts hästar som kommer från helt olika bakgrunder, som visat såväl färska formbesked som har total avsaknad av detsamma samt nytillskott i klassen. En sak är i alla fall säker och det är att inget talar för att det ska börja ta emot för <strong>Amalencius B.B.</strong> bara för att han fått 330.000 kronor på sig vid sina två senaste segrar i Klass I. Detta är en potentiell klassklättrare som besegrade kulltoppar i höstas och han kan mycket väl bli lördagens största favorit på V75-spelet. <strong>Asteroid</strong> hade en stark treåringssäsong och vann bland annat Big Noon Pokalen. Nu möter han äldre konkurrenter i sin årsdebut och han gör det dessutom från bakspår. <strong>G.K.Justus</strong> tycks aldrig kunna göra en dålig insats och blir per automatik tidig från ett gynnsamt startspår medan <strong>Best ofdream Trio</strong> som är färsk i klassen känns mindre intressant denna gång från spår tolv i en högre klass. Ja, han stod för en svettig insats senast på Axevalla, men här är konkurrensen en helt annan.</p>
<h2>Avd 6 – Diamantstoet, 2.140 meter voltstart</h2>
<p>Efter en stark dödensinsats i tuff stoomgivning inom V75 Champions och efter en bra avslutning i Klass I mot hingstar lär <strong>Olga Tooma</strong> bli väl påpassad i detta lopp från springspår. Skulle hon nå ledningen kan loppet vara över, men med minsta strul finns det många om budet. <strong>Sanibel</strong> övertygade vid segern senast i V75 Champions, men fick 150.000 kronor på sig i och med den fullträffen och snabbt kommit upp i klass. <strong>Love You Sweden</strong> har gått från klarhet till klarhet denna vinter. Segrarna har tagits i enkla gäng, men hon såg så pass fin ut vid dödenstriumfen senast i Gävle att hon känns aktuell även här. <strong>Honesty</strong> upplever vi som lite segstark och inte helt ren i gången. Det känns inte som hon kommer stå för någon snabbstart från spår två ur volten utan riskerar att hamna en bit bak. <strong>Nina Ginto</strong> var rejäl vid segern i Diamantstoet på Axevalla och <strong>Icecream In</strong> som var betrodd i samma lopp jagar revansch efter att felat bort sig efter omstarter i samma lopp.</p>
<h2>Avd 7 – Silverdivisionen, 2.140 meter autostart</h2>
<p><strong>Phoenix Photo</strong> har redan tagit hem två försök av Silverdivisionen detta meeting och kan mycket väl fylla på med en tredje. Han har varit fenomenal vid segrarna och stod framförallt för en svettig insats senast på Bergsåker där han löste biffen trots en blytung resa. <strong>Unico Broline</strong> har även han vunnit ett silverdivisionsförsök detta vintermeeting. Han var bara bäst hemma på Axevalla och med tanke på den kurvan den här hästen har haft i sin utveckling så måste vi tro på en ny toppinsats. <strong>A Good Point</strong> var urtapper från dödens i lördags medan stallkamraten <strong>Sweetman</strong> satt fast med rubbet sparat bakom den trötta ledaren Hollywood Story. <strong>Öppnar Baritone Artist</strong> lika bra som han gjort tidigare denna vinter så kanske ett rygglopp bakom Sweetman kan vara av intresse och då är han absolut bra nog för att leverera en frän slutrökare på open stretch-spåret. <strong>Devs Daffodil</strong> flög förbi sina konkurrenter i Diamantstoet i lördags. Vi tror att hon närmast gynnas av att möta ännu tuffare hästar för då kan det bli bra tempo på loppet vilket verkligen faller henne i smaken.</p>
