
<p class="has-drop-cap wp-block-paragraph">Nej, det är ingen straffspark utan målvakt, men likt en straffspark med målvakt kan man i vilket fall jämställa den uppgift som <strong>Corazon de B. </strong>(V75-7) står inför inom lördagens V75-omgång.</p>



<p class="wp-block-paragraph">Per Lennartssons häst spårade hem Silverdivisionsfinalen på Solvalla under annandag jul efter att tagit ledningen från spår ett bakom bilen och vi tror att det scenariot upprepar sig på nytt.</p>



<p class="wp-block-paragraph">Flera av loppen denna lördag på Romme tycker vi är ojämna och vi spelar med två spikar och ett tvåhästarslås för att på så vis kunna gardera friskt i de två lopp som vi däremot bedömer vara riktigt öppna.<br>I lärlingsloppet känns inte <strong>Solöns Skrammel</strong> (V75-2) som en häst att hålla i handen och vi vågar inte heller lita på den osäkra kallblodsduon<strong> Guli Fantom</strong> och <strong>Brenne Rön</strong> (V75-4). Tio respektive nio markeringar kostar vi på oss i de loppen och hoppas på skräll!</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/01/06v75.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till tävlingarna på Romme.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2024-01-06_23_5" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2024-01-06_23_5" target="_blank" rel="noreferrer noopener">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206689_V75_2024-01-06_23_5" target="_blank" rel="noreferrer noopener">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



<h2 class="wp-block-heading">Avd 1 – Bronsdivisionen, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Xanthis Hilton </strong>kunde inte hålla upp innerspår i Bronsdivisionsfinalen senast på Solvalla och blev därefter fast med rubbet sparat i rygg på en trött Glorious Rain. Gången innan fick han dödens initialt innan han blev avlöst varvet före mål och senare kunde vänta med attacken fram tills upploppet. Det var med lätthet som han avgjorde över spurtrakan den dagen och allt tyder på att hästen har lika bra form nu som då. Som trolig ledare av det här loppet talar väldigt mycket för att Xanthis Hilton avgår med segern.</li>



<li><strong>Declan</strong> var med i samma bronsfinal som Xanthis Hilton senast på Solvalla. Då blev han över från start, fick backas ner som fjärdehäst längs sargen och hakade på lättsamt mellan hästar till slut utan att få helt fritt. Även om placeringarna inte har varit de allra bästa i de tre starter han gjort i vinter med skor på hovarna så har vi varit nöjda med insatserna och ser honom som det klart hetaste motbudet i denna förhållandevis tunna bronshistoria.</li>



<li><strong>Babsans Bankir </strong>fick dra tåget som förstahäst i tredjespår de sista 1.100 meterna senast på Färjestad. Det var mer eller mindre snöstorm den dagen och den utmaning han ställdes inför var honom övermäktig. Hästen är ingen startblixt och riskerar att hamna en bit bak startspåret till trots, men med draghjälp fäller han många till slut.</li>



<li><strong>Global Crusader </strong>tog ner M.T.Montpellier från dödens senast, men fick sträcka vapen för Chitchat. Det var verkligen inget som han behövde be om ursäkt för utan insatsen var riktigt tapper. Spår tolv känns dock &#8221;öken&#8221; och uppgiften han ställs inför här är tuff.</li>



<li><strong>Ready Trophy </strong>kom aldrig till i V75-loppet senast i Mantorp, men gick helt okej i skymundan. Han brukar gå bra på vintern och räds inte svåra förutsättningar.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>5 <strong>B: </strong>7-3-12-10-4-11-6-2 <strong>C: </strong>8-1-9</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Xanthis Hilton</strong> har hållit ut <strong>Declan</strong> tidigare och ska ha toppchans att göra det på nytt.</p>



<h2 class="wp-block-heading">Avd 2 – Lärlingslopp, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Solöns Skrammel </strong>kan tyckas vara en underlig tipsetta i detta lopp utifrån insats senast i Gävle. Då fick hon dock gå i rygg och det är inte alls den här damens melodi. Gången innan fick hon lägga en tuff speed för att nå ledningen och höll med tanke på det starkt som trea. Vi tycker inte att det här loppet håller någon högre klass och över 1.640 meter blir hon hästen att slå som trolig ledarinna.</li>



<li><strong>Gentleman Sisu </strong>gick en riktigt bra långspurt i Gävle näst senast och var därefter tapper från dödens. Han kan inte hålla upp någon ledning från innerspår, men har alla möjligheter att få en fin, invändig smygare och då biter hans spurt riktigt vasst bara han får chansen.</li>



<li><strong>B.G.Pastor Jonte </strong>såg jättefin ut vid spetssegern senast. Här är förutsättningarna helt annorlunda, men hästen är inte beroende av ledningen och står fördelaktigt inne i denna spårtrappa.</li>



<li><strong>Nuzzle&#8217;em </strong>har inte glänst i de två senaste starterna och vi plockar därför ner honom i B-gruppen. Löper han upp till sin högstanivå så vänder han troligtvis ut och in på det här sällskapet, men just nu är det för tveksam form på hästen för att vi riktigt ska kunna lyfta honom i det här loppet.</li>



<li><strong>Chip Shop </strong>är jämnheten själv i prestationerna och tävlar framgångsrikt med skor på hovarna. Han tar många till slut i det här loppet på sin goda förmåga att hålla tempot uppe.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>6-1-12 <strong>B: </strong>9-5-7-4-11-3-2 <strong>C: </strong>8-10</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Ajlexes Abraxas</strong> får svårt att hålla ut <strong>Solöns Skrammel</strong>.</p>



<h2 class="wp-block-heading">Avd 3 – Klass II, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Janks Morton</strong> har kommit tillbaka starkt efter långt uppehåll och ser ut som en häst med mycket utveckling kvar i sig. Han kunde forceras till ledningen i ett tidigt skede senast och svarade säkert i slutskedet. Gången innan fick han ta dödens på slutvarvet och höll farten starkt till andraplatsen. Hästen blir spänstigare för varje start och vi tror att han kan vara med så pass bra från början att han kan forceras till ledningen i tidigt skede.</li>



<li><strong>Papa Rock </strong>är dock ingen enkel konkurrent. Efter att gått segerlös genom de första åtta starterna så har det släppt ordentligt för Tuomas Korvenojas häst som nu radat upp fem raka segrar. Han har sett häftig ut vid varje tillfälle då han fått löpa ut i ledningen, men skulle han bli snuvad på tät från innerspår vilket absolut känns möjligt så är han direkt sårbar för här är motståndet tuffare än det han mött i Finland och man vinner inte på beställning från dödens.</li>



<li><strong>Bengt</strong> har två raka Klass II-starter bakom sig utan någon vidare lycka. Senast i Gävle galopperade han som andrahäst efter 300 meter efter att öppnat raskt, men såg vettig ut då han kördes runt i all enkelhet bakom fältet. I grunden är Bengt bra nog för att duga i Klass II och vi håller som som garderingsbud för den som vill gå utanför A-gruppen.</li>



<li><strong>Cumulus F.G. </strong>tog över ledningen efter att gnuggat dödens redan 900 kvar senast och gick ifrån till säker seger. Det var en rejäl insats, men vi kan inte blunda för att han ser ut att lyfta i jänkarvagn och det får inte nyttjas nu när det är voltstart.</li>



<li><strong>Global Dependable</strong> satt fast med sparade krafter via vinnarhålet senast i ett Klass II-försök, men här är förutsättningarna annorlunda med bakspår och full distans.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>3-1 <strong>B: </strong>4-12-10-11-5 <strong>C: </strong>6-8-7-9-2</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Vi tror att<strong> Lamborghini C.Boko</strong> tar ledningen och släpper till den av <strong>Janks Morton </strong>och<strong> Papa Rock </strong>som kommer fram först. Vi håller det mest sannolikt att det blir Janks Morton som övertar.</p>



<h2 class="wp-block-heading">Avd 4 – Kallblodsdivisionen, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Brenne Rön</strong> var hårt betrodd inom just V75 senast i Bollnäs, men då blev det galopp kort efter start. Upphämtningen till femteplatsen var sannerligen god och den här hästen är mycket bättre än vad resultatraden just nu antyder. I felfritt lopp så tror vi att Brenne Rön är den som avgår med segern.</li>



<li><strong>Guli Fantom </strong>är en segermaskin som återfunnit just vinstgnistan efter en period med sju raka starter utan seger. Nu står han åter med tre raka fullträffar bakom sig och vi gillade verkligen sättet som han gick ifrån sina konkurrenter på från ledningen i näst senaste starten. Även om han inte tar hand om ledningen direkt så är det sannolikt att han kan forceras till tät i tidigt skede och då blir han svårfångad.</li>



<li><strong>Soldhöjdens Drake </strong>fick göra allt jobb själv på slutrundan i Bollnäs och vi tycker att han föll med flaggan i topp som trea. Han har verkligen samlat ihop till en seger nu, men risken är påtaglig att han återigen för ta på sig blåstället och nöta på av egen kraft ute i spåren.</li>



<li><strong>Tekno Jerven </strong>höll riktigt bra som dödenstvåa bakom Månlykke A.M. på Bergsåker, men slog på en galopp från start gången efter. Han är inte helt att lita på, men har kunnande nog för att utmana om han håller sig på benen.</li>



<li><strong>Pave Sokken </strong>stod för en stark dödensinsats i enklare sällskap senast. Får han ett lopp i draget nu så är han inte helt golvad trots tuffare konkurrens.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 10-2 <strong>B: </strong>13-15-7-3-8-4-5 <strong>C: </strong>11-14-12-6-1-9</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Även om <strong>Ros Borken</strong> tar sig förbi initialt så tror vi man släpper till <strong>Guli Fantom</strong> i nästa skede.</p>



<h2 class="wp-block-heading">Avd 5 – Klass I, 2.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Mellby Knekt </strong>höll upp ledningen med lätthet från spår ett senast i finalen av Solvallaseriens lägsta klass. Han var aldrig nära att släppa greppet om det loppet efter det och tveklöst så rör sig detta om en mycket talangfull häst. Distansen förväntar vi oss att han står utan problem med Mellby Viking som far, men det finns ett par formstarka motståndare med och det är lite mer svårbedömt hur tävling med skor kommer att påverka Mellby Knekt.</li>



<li><strong>Rajon</strong> var Örjan Kihlström med rätt så bra med från start senast, men tog upp redan efter 25-50 meter då han insåg att han inte skulle komma förbi de invändiga. Från fjärde invändigt löste det sig först i sent skede och Rajon sköt till riktigt bra till andraplatsen bakom Silent Eagle. Vi kan se Örjan Kihlström vara mer aktiv nu för att ta position direkt och vill inte spela utan Rajon på vår kupong.</li>



<li><strong>The Pirate </strong>var tapper dödenstvåa bakom Chimi i näst senaste starten, men satte inte en fot rätt gången efter utan försvann direkt på kör när det var voltstart. Nu är det åter autostart och vi tycker inte att det här Klass I-försöket är nämnvärt tuffare än de sällskap han matchats i på sistone.</li>



<li><strong>Gasparito</strong> snabbstartade till ledningen senast i Klass I-försöket innan täten släpptes. Han kunde inte riktigt haka på till slut, men höll ändå farten bra som trea.</li>



<li><strong>Kee Keeper </strong>gjorde det bra vid spetssegern senast på Romme, men när det nu handlar om 2.640 meter och tuffare motstånd så tror vi att man släpper ledningen.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>7-4-8<strong> B: </strong>3-2-10-11-9 <strong>C: </strong>6-1-5-12</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Kee Keeper </strong>bör vara först ner till plankan, men lär utmanas per omgående. Vi bedömer <strong>Rajon</strong> som mer startsnabb än vad han riktigt visat såhär långt och kan se honom hålla ut <strong>Mellby Knekt</strong>. Dock kan det vara så att Jorma Kontio bara kör och kör tills han väl sitter i tät med den sistnämnde.</p>



<h2 class="wp-block-heading">Avd 6 – Diamantstoet, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Madewithlove</strong> vann ett försök till Oaks i höstas trots galopp, men slog på dubbla felsteg i finalen och fick ingenting med sig från det loppet. Även om skorycket gjorde effekt på henne så tycker vi att hon gått så pass bra med skor att hon ska kunna prestera på en hög nivå även med den balansen. Stoet återkommer efter paus, men står inför en överkomlig uppgift.</li>



<li><strong>Jewilla</strong> fick göra en hel del jobb själv innan hon efter hand nådde ledningen senast i finalen av Diamantstoet. Vi tycker att hon höll ställningarna bra som tvåa och det här stoet har inte gjort en dålig insats på mycket länge. Jewilla blir en faktor att räkna med även i det här loppet.</li>



<li><strong>Udine Celeber</strong> kördes spårsnålt i finalen av Diamantstoet och satt fast med sparade krafter. Stoet har mycket bättre form än vad resultatraden antyder och chans att få en vettig position långt fram i fältet.</li>



<li><strong>Jurista</strong> tappade sin draghjälp redan halvvarvet före mål i Diamantstofinalen senast på Solvalla, men höll farten bra som trea. Hon tar många på slutarvet.</li>



<li><strong>Donna Summer </strong>var även hon med i Diamantstoetfinalen senast och satt fast med sparade krafter som femma. Hon kan bli över från början från innerspår och hamna bland de sista i fältet, men skulle hon få hjälp på vägen så tar hon många till slut.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>7-12-2 <strong>B: </strong>15-10-6-8-3-14-11 <strong>C: </strong>5-13-4-1-9</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Vi bedömer springspårshästarna klart snabbast initialt och tror att <strong>Madewithlove</strong> får överta ledningen från <strong>Jes Angel </strong>om den sistnämnda frontar.</p>



<h2 class="wp-block-heading">Avd 7 – Silverdivisionen, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Corazon de B. </strong>kommer från en mycket positiv insats då han spårade hem varje meter av Silverdivisionens final. Hästen öppnade i våra ögon oväntat snabbt den dagen och höll ut väl så raska konkurrenter som han stöter på denna gång. Med tanke på den startsnabbhet som han då visade så ska hans spetschans vara mycket god på nytt i ett lopp där det inte finns så många startsnabba hästar med i startlistan. Har hästen bibehållet formen så ska han ha jättechans att spåra hela vägen.</li>



<li><strong>S.G.Mistral</strong> satt sist i fältet 300 meter före mål senast i Bronsdivisionens final, men avslutade strålande och nådde andraplatsen bakom Chitchat. Det var ett formbesked som hette duga och vi kan faktiskt inte minnas när den här hästen gjorde en dålig insats senast. Denna tid på året går det inte lika fort i loppen och det talar för att spurtstarke S.G.Mistral lättare ska kunna anpassa sig till den nya nivån med tävling i Silverdivisionen som han nu ställs inför.</li>



<li><strong>Marre&#8217;s Dreamboy </strong>är givetvis mycket svårbedömd inför sin återkomst då han inte tävlat sedan i april. Däremot så levererade hästen starka insatser på just skor förra vintern så det i sig är ingen stor sak för hans del. I någorlunda form så duger han bra i ett sådant här gäng.</li>



<li><strong>Global Classified </strong>fick för långt fram i spurten senast i finalen av Guldklockan, men stod för en vettig avslutning. Vi tror inte att han kommer förbi favoriten direkt, men en ryggresa bakom Corazon de B. behöver inte alls vara fel för hans del.</li>



<li><strong>Oxidizer</strong> fick en invändig resa i Silverdivisionen i Mantorp, kom upp i rygg på vinnaren Major Ass över spurtrakan och satt fast med sparade krafter. Han har lyft markant nu efter en downperiod och är ett bud för den som vill gardera storfavoriten.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>1 <strong>B: </strong>3-9-2-5-11 <strong>C:</strong> 4-8-12-7-6-10</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Vi ser <strong>Global Classified</strong> som det enda riktigt heta hotet till <strong>Corazon de B. </strong>i spetskampen och när de står sida vid sida ska det vara god chans att favoriten håller ut.</p>



<p class="wp-block-paragraph">	
				<div class="factbox full ">
			<div class="insidefactbox">
				<div class="overflow">
					<div class="height">
						<div class="padding">
							<div class="factvinjett">Fakta</div>
							
															<h3 class="title">
									V75-FÖRSLAGET 6 DECEMBER								</h3>
														<div class="content">
								
<p class="wp-block-paragraph"><strong>Avd 1: </strong>5 Xanthis Hilton (7,3)<br><strong>Avd 2: </strong>1,2,3,4,5,6,7,9,11,12 (8,10)<br><strong>Avd 3: </strong>1,3 (4,12)<br><strong>Avd 4: </strong>2,3,4,5,7,8,10,13,15 (11,14)<br><strong>Avd 5: </strong>4,7,8 (3,2)<br><strong>Avd 6: </strong>2,3,6,7,8,10,12,15 (14,11)<br><strong>Avd 7: </strong>1 Corazon de B. (3,9)</p>



<p class="wp-block-paragraph"><em>4.320 rader / 2.160 kronor</em></p>
							</div>
						</div>
					</div>
				</div>
							</div>
		</div>
	
	</p>
