<p>När ingen lyckades pricka in sju rätt i lördagens V75-omgång på Åby går 19.777.228 av 24.721.536 kronor  in i lördagens sjurättspott när omgången avgörs i Mantorp.</p>
<p>Omgången ser ut att innehålla tre sannolikt stora favoriter vid en första anblick. <strong>Disco Volante </strong>(V75-3) har väldigt passande förutsättningar i Gulddivisionen och vi har förståelse för om han blir omgångens &#8221;megalampa&#8221;.</p>
<p>Möjligen kan det bli knivigare för de andra, sannolik stora favoriterna. <strong>Jaguar Dream </strong>(V75-5) har bara ett lopp i kroppen efter lång frånvaro. Han övertygade förvisso vid comebackvinsten, men nu hårdnar konkurrensen och skulle han bli snuvad på taktpinnen från innerspår så är han farligt ute.</p>
<p>Just innerspår har även <strong>Maestro Crowe </strong>(V75-7) lottats till i klass I-försöket. Det utgångsläget har han inte lyckats förvalta tidigare och det föreligger faktiskt en viss risk att han till och med hamnar sist initialt. Då är det aldrig enkelt att lösa uppgiften i STL-sammanhang så här finns det all anledning att fundera kring favoritens faktiska möjligheter.</p>
<ul>
<li><a href="https://sulkysport.se/wp-content/uploads/2021/02/20v75.pdf" target="_blank" rel="noopener noreferrer">Här kan du ta del av lördagens startlistor till Mantorps tävlingar.</a></li>
</ul>
<h2>Avd 1 – Bronsdivisionen, 2.140 meter voltstart</h2>
<p><strong>Phoenix Photo</strong> var mycket bra då han klev ut som färsk bronsdivisionare på Sundbyholm och löste loppet från ledarens utsida. Den här gången står han med stängt startspår, men det är sällan vi ser favoriter sitta fast i fjärde invändigt med toppkuskar inom V75-spelet&#8230; <strong>Sweetman</strong> vann klass I-finalen från ledningen. Det kan bli knivigare att vända honom till den positionen från snävt startspår, men det ska sägas att Erik Adielsson är en mästare i voltstart. <strong>Racing Ribb</strong> och <strong>Upstate Face</strong> är två formstarka stallkamrater med bevisad form och <strong>Exclusive Matter</strong> gjorde likaså en bra insats i lördags bakom <strong>Morotai Degato</strong>.</p>
<h2>Avd 2 – Klass II, 1.640 meter autostart</h2>
<p>Ett kul klass II-försök där det är många deltagare som har friskt med ettor i raden och visat stark vinterform. Allra mest har <strong>Zack Bris </strong>övertygat på oss. Han gick en häftig långspurt bakifrån i senaste starten, men förlorade starten innan från tät. Då tror vi att Oskar Kylin Blom helt enkelt körde för sakta för hästen förlorade mot en speedigare häst i en pilsnabb avslutning. <strong>Lumbermans Kalle </strong>uppmärksammade vi friskt efter segern i tisdags på Axevalla då han var överlägsen trots att han verkligen synades. Spår tolv känns tufft att lösa den här uppgiften från, men det ska sägas att han har vunnit även bakifrån. <strong>Bravo Tessla </strong>har också varit fin vid segrarna, men står med besvärligt utgångsläge och kommer behöva tur. <strong>Harvard Student </strong>har varit fin vid segrarna i enkla sällskap på Axevalla och då har det dessutom varit öppet läge. Nu får hon kriga på bakifrån mot pojkarna. <strong>Mascarpone Doc </strong>har två raka segrar, men hur bra han är känns svårt att bedöma.</p>
<h2>Avd 3 – Gulddivisionen, 2.140 meter autostart</h2>
<p>Det var verkligen inget fel på <strong>Disco Volantes </strong>insats i Gulddivisionsfinalen som fyra och den här gången står han bättre placerad med bricka tre bakom bilen. Det är sannolikt att han når ledningen och att vinner loppet. <strong>Hawk Cliff </strong>smögs fram perfekt av Mika Forss i Gulddivisionsdebuten och avgjorde på tilltalande vis. Han duger absolut i det här loppet också, men lär bli passerad av Disco Volante i starten och då blir det direkt tuffare. Gulddebutanten <strong>Night Brodde </strong>och stallkamraten <strong>Breidabliks Nubbe </strong>kommer båda med bevisad form och i slag är även <strong>Zenit Brick</strong>, men när den trion jagar från bakspår gentemot Disco Volante så känns det tufft.</p>
<h2>Avd 4 – Diamantstoet, 1.640 meter autostart</h2>
<p>Ett lurigt stolopp vid en första anblick. Trots att vi egentligen upplever <strong>Appaloosa </strong>som mer stark än snabb så har hon löst två raka sprinterlopp och matchas över distansen på nytt. Bo Falsigs sto kan helt enkelt ha breddat sin repertoar och tillhör skaran segerbud i det här loppet också även om vi inte ser henne som någon spik. <strong>Call Me Brodda </strong>kommer säkert få många anhängare på spetsläge och Stefan Persson i sulkyn. <strong>Artemide Zack </strong>har gjort bra lopp varje gång i vinter och det känns inte som hon står hårt inne kapacitetsmässigt i det här loppet även om pengarna hon bär antyder annat. Totalt sett är som sagt loppet riktigt öppet och här kan lägesmissgynnade, men bra hästar som <strong>Bianca Sisa</strong>, <strong>Svecak Palema</strong>, <strong>Mellby Eye Catcher</strong> och <strong>Xanthis Delicious </strong>bli kittlande lite spelade.</p>
<h2>Avd 5 – Silverdivisionen, 2.140 meter autostart</h2>
<p>Är det så enkelt att <strong>Jaguar Dream </strong>spårar hem varje meter av det här loppet? Claes Sjöströms häst såg jättebra ut i comebacken efter 20 månaders uppehåll då han speedade ner <strong>Dom Perignon </strong>från vinnarhålet med bra fart över målgången. I &#8221;sin ungdom&#8221; var han svår att ta en längd på bakom bilen, men det är klart att det är något annat nu när han han möter äldre hästar. <strong>Franklin Face </strong>går bra varje gång i silverdivisionen och hans möjlighet här ökar givetvis om han kommer förbi den sannolika favoriten direkt. Oskar J Andersson har stabiliserat <strong>My Dream Art </strong>och därtill fått bra resultat med hästen, men här stundar en annan typ av uppgift ska tilläggas. <b>Jaques Noir </b>återkommer efter tre månaders tävlingsuppehåll och hur statusen är på honom står skrivet i stjärnorna.</p>
<h2>Avd 6 – Diamantstoet, 2.140 meter voltstart</h2>
<p><strong>Princess S.W. </strong>jagade ikapp från 40 meters tillägg i lördags, men det var mot något sämre hästar och frågan är hur hon reagerar på att starta så här pass tätt som nu blir fallet. Stallkamraten <strong>Velegance </strong>var bra som fyra i Stoeliten på Solvalla och i samma lopp var <strong>Hossiana Boko </strong>tvåa. De är båda tidiga bud här som känns lika heta som den sannolika favoriten. På mellanvolten gillar vi <strong>Hillbilly Woodland </strong>mest som lätt kan tappas på en sämre placering senast på Solvalla i Diamantstofinalen. Av startvoltens tre hästar blir säkert <strong>TheBankonBroadway </strong>mest betrodda med tre segrar på de fyra senaste starterna. Här är dock konkurrensen en helt annan än vad den varit vid segrarna och då tycker vi att <strong>Kiss My Boko </strong>är väl så intressant efter att hon gått ett jättebra slutvarv senast i Eskilstuna från djup köposition.</p>
<h2>Avd 7 – Klass I, 2.640 meter autostart</h2>
<p>Lördagens klass I-försök såg ut att vara vikt för <strong>Maestro Crowe </strong>när man ögnade igenom anmälningslistan, men sedan lottades han till innerspår bakom bilen och vips så öppnas loppet upp. Hästen har sett stark ut i sina två starter i Johan Untersteiners regi, men hamnade sist från samma läge senast på Jägersro och det är upplagt för strul initialt från det här utgångsläget. Vilka som utmanar? <strong>Llama Tooma </strong>har varit så pass rejäl vid triumferna att vi måste ta honom på allvar här också. <strong>L.L.Royal </strong>såg mycket bättre ut senast än han gjorde i några starter dessförinnan och en <strong>Don Cash </strong>som hushåller med krafterna är också en faktor i det här loppet. Varken <strong>Leon Zon </strong>eller <strong>Bravo Santana </strong>känns heller chanslösa från det här utgångsläget så avslutningen blev plötsligt en smula lömsk med tanke på att favoriten just fick det för honom sämsta tänkbara utgångsläget.</p>
