<p><span class="anfang">J</span>ägersro arrangerar veckans jackpotkryddade V75-omgång som håller hög, sportslig klass. Det kryllar av segermaskiner i startlistorna, men såhär i början på veckan är det svårt att sätta fingret på svårighetsgraden ur ett spelperspektiv.</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 JÄGERSRO								</h3>
<div class="content">
								<strong>Längd: </strong>1.000 m<br />
<strong>Bredd: </strong>23,0 m (2.140 m), 23,0 m (1.640 m)<br />
<strong>Upplopp: </strong>190 m<br />
<strong>Open stretch: </strong>Nej<br />
<strong>Vinklad startbilsvinge:</strong> Ja							</div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
<p>Även om Gulddivisionen – tillika första uttagningsloppet till Paralympiatravet – givetvis är superspännande med <strong>Very Kronos</strong> (V75-7) som förgrundsfigur så tycker vi att Klass I- och Silverdivisionensförsöket är lika aptitliga godbitar.<br />
I det förstnämnda loppet jagar bland annat <strong>Under Armour</strong> sin sjätte raka seger, men ska försöka stoppas av Adrian Kolgjinis <strong>Akilles Face</strong> som visade stort kunnande i kvalificerade omgivningar i höstas.<br />
I Silverdivisionen ska <strong>Rackham</strong> försöka ta revansch på <strong>E.Type Cash</strong>, men duon är inte givna vinnare utan här syns även <strong>Oscar L.A.</strong> och <strong>Sam the Man</strong> som högintressanta objekt som utmanar.</p>
<p><a href="https://sulkysport.se/wp-content/uploads/2022/04/09v75.pdf" target="_blank" rel="noopener">Här kan du ta del av lördagens startlistor till tävlingarna på Jägersro.</a></p>
<h2>Avd 1 – Diamantstoet, 1.640 meter autostart</h2>
<p><strong>Lady Beluga</strong> försvann direkt i starten när hon skulle försöka bärga sin sjunde raka seger i onsdags. Nu laddar hon om och kliver ut i STL-sammanhang mot tuffare hästar än vad hon någonsin tidigare stött på. Hon har haft innerspår bakom bilen vid ett tillfälle tidigare och då frontade hon enkelt, men det var i en lägre klass än hon tävlar i nu. <strong>Georgia Am</strong> såg väldigt stark ut i årsdebuten på Axevalla. Hon fick förvisso bestämma tempot under inledningsvarvet, men fick därefter rejäl press och kunde likväl gå undan till en säker seger. <strong>Helloise Am</strong> har levererat starka insatser vintern igenom och tuffat till sig. Nu växlar man upp och kör henne såväl barfota runt om som med jänkarvagn.<strong> Excuse Me</strong> besegrade <strong>Woodbury Wine</strong> regelrätt från dödens på Jägersro och känns som den hetare av dem även denna gång när hon fått det mer gynsamma bakspåret av de två.</p>
<h2>Avd 2 – Klass II, 2.640 meter voltstart</h2>
<p><strong>Kentucky River</strong> stod för en mycket stark insats i debuten i Per Nordströms regi. Trots att han fick harva utvändigt ledaren så hade han avgjort loppet redan på sista bortre långsidan och gick ifrån till en övertygande seger på en för klassen riktigt stark tidsnotering. Han blir sannolikt favorit i det här loppet och det motsätter vi oss inte rent spontant. <strong>Lucky Guy Boko</strong> har nio starter in i karriären aldrig varit sämre än trea i något lopp. Han höll starkt efter tuff resa i comebacken. Från innerspår kan det bli ledning och nu har Joakim Lövgren anmält hästen barfota runt om för blott andra gången. <strong>Le Piment</strong> galopperade med grepp om loppet vid upploppets början senast på Jägersro. Nu blir det en och en halv månad mellan starterna vilket oroar, men vad det gäller grundklass är vi trygga vid att han hävdar sig för insatsen han stod för i Kalmar i januari var rent ruggig! Vi tycker att den nämnda trion höjer sig över mängden och bedömer gänget där bakom som väldigt jämna sinsemellan.</p>
<h2>Avd 3 – Silverdivisionen, 2.640 meter autostart</h2>
<p>Vilket lopp!<strong> E.Type Cash</strong> och <strong>Rackham</strong> möttes på Jägersro i onsdags och då var det den förstnämne som gick segrande ur striden. Han levererade en ruskig långspurt och lyckades fånga in Rackham i sista steget som hade fått harva i dödens i sin årsdebut och båda hästarna levererade verkligen femstjärniga insatser. De är givna bud i det här loppet, men motstånd saknas inte utan här finns det flera fina toppar. Bland dem räknas givetvis <strong>Oscar L.A.</strong> som hann göra två Silverstarter i höstas innan han fick en vinterpaus. Han var dödenstvåa bakom Adde S.H. i oktober, är än mer gynnad av denna distans och har vässat formen i provlopp inför sin återkomst så vi räknar kallt med att han kommer kunna leverera direkt när Joakim Lövgren väljer att börja året i ett sådant här sammanhang. <strong>Sam the Man</strong> har tre segrar på fem starter på svensk mark och gör nu sin första start på blågul mark under Björn Goops flagg. Han avslutade ruskigt vasst som trea senast i Mauquenchy och vi har sett så många gånger tidigare hur hästar kan lyfta sig ett snäpp till efter en härdande vinter i Frankrike.</p>
<h2>Avd 4 – Diamantstoet, 2.140 meter voltstart</h2>
<p>Ett lurigt stolopp där hästarna är jämnt fördelade på de tre olika volterna. <strong>Eenymeenyminymoedk</strong> flög fram i spurten på Axevalla och vann därefter ett enklare stolopp från dödens i Odense. Däremot fungerade hon inte som bäst senast på Solvalla, fick aldrig riktigt kontakt med fältet och galopperade på sista bortre långsidan. Normalt sett ska detta vara en passande uppgift för henne, men senaste insatsen i kombination med att det kan bli långt fram på en snabb vårbana gör att hon känns sårbar. Stefan P Petterssons hästar går vansinnigt bra för dagen. <strong>Chantal Jet</strong> svek förvisso som favorit senast på Solvalla, men känslan var att täta starter blev för mycket för henne. Nu laddar hon om från ett passande innerspår på tillägg och blir giftig om hon får spara speeden. <strong>Namanga Bo</strong> var riktigt fin vid Diamantstosegern på Momarken, men står likt Eenymeenyminymoedk inför en utmanande uppgift från bakre volten. Vi finner ingen häst som startvolten som vi känner helhjärtat för, men konstaterar att formstarka <strong>Timeless</strong> har tre segrar på en tredjeplats på fyra försök när hon har körts i ledningen.</p>
<h2>Avd 5 – Klass I, 2.140 meter autostart</h2>
<p>Ett oerhört bra Klass I-försök! <strong>Under Armour</strong> är på jakt efter sin sjätte raka seger och vi kan inte säga att han kommer misslyckas med att bärga den. Han vann spårlottningen av de hästar som lär bli mer betrodda i loppet och såg riktigt stark ut i årsdebuten. <strong>Akilles Face</strong> vann Johan Jacobssons Minneslopp i höstas före så bra hästar som Ikaros Sisu och Felix Orlando. Det säger väldigt mycket om vilka resurser som finns i den här hästen som måste räknas direkt trots att det handlar om årsdebut. <strong>High Line Pellini</strong> var trea från dödens i Klass II-försöket i Kalmar där Il Forte dundrade runt på i överljudsfart. I genrepet i Gävle släpptes han till tät och såg läcker då han gick undan till vattentät seger. <strong>King of Greenwood</strong> gick en rejäl 700 metersrepa senast på Åby och övertygande, men hur ska han samt segervane <strong>Indigo</strong> kunna komma in i det här loppet från spår elva respektive tolv?</p>
<h2>Avd 6 – Bronsdivisionen, 1.640 meter autostart</h2>
<p><strong>Tom n&#8217;Jerrydimant</strong> har övertygat vid vinterns segrar på svensk mark, men ströks på grund av dåliga blodvärden på Åby i mitten av mars. Familjen Nimczyks hästar har haft ett uppehåll på grund av den sjukdomsbild som fanns i stallet under den nämnda perioden och även <strong>Orkan von Haithabu</strong> som startar i det här loppet ströks inför en tilltänkt start under samma period. Den nämnda duon har verkligen övertygat i sina starter här, men blir per automatik svårbedömda på grund av hur förberedelserna upp till denna start har sett ut.<strong> King Schermer</strong> trodde vi hårt på i Sylvesterloppet under Nyårsafton, men den dagen blev upplägget för tufft i kvalificerad omgivning. Han har visat form på hemmaplan i vinter och hävdade sig i riktiga bra årgångslopp här i Sverige under fjolåret.<strong> Eros Zola</strong> väljer Flemming Jensen att ta ut i STL-sammanhang direkt i årsdebuten; ett beslut som vi har stor respekt för och tolkar som en tydlig signal på att han har hästen i rätt slag direkt, men hur ska hästen lyckas komma till från spår åtta?</p>
<h2>Avd 7 – Gulddivisionen, 2.140 meter autostart</h2>
<p><strong>Very Kronos</strong> lär ha hostat rejält efter årsdebuten och var helt enkelt nedsatt den dagen. Med tanke på det så fäster vi ingen vikt vid själva insatsen utan konstaterar bara att han fått ett lopp i kroppen nu, har ett perfekt utgångsläge och därtill är anmäld barfota runt om. Den här uppgiften ser lämplig ut på pappret och han ska normalt sett bli väldigt svårslagen.<strong> Express Jet</strong> har tävlat i stentuffa gäng på Vincennes vintern igenom och var faktiskt inte så långt ifrån att kvala in till Prix d&#8217;Amerique. Hästen känns effektivast när han får gå på innerspår, långt fram i fältet och spara speeden och det finns en rimlig chans att det kan bli ett sådant upplägg från det här utgångsläget. <strong>Upstate Face</strong> spurtade starkt i årsdebuten och blev därefter fast för länge i finalen på Solvalla. Vi står fast vid att vi förväntar oss en toppsäsong från hans del, men tycker att den här uppgiften är svår när han har Very Kronos på sin insida. <strong>Diamanten</strong> var positiv i årsdebuten och står intressant placerad bakom vingen medan årsdebutanterna <strong>Sevilla</strong> och<strong> Racing Mange</strong> känns bortlottade från spår nio respektive elva.</p>
