"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>BLUECAP LOG FUNDO DE INVESTIMENTO IMOBILIÁRIO</NomeFundo>
		<CNPJFundo>49592781000140</CNPJFundo>
		<DataFuncionamento>2023-02-14</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRBLOGCTF001</CodigoISIN>
		<QtdCotasEmitidas>23562047</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>true</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Multiestratégia</Classificacao>
			<Subclassificacao>Não possui subclassificação</Subclassificacao>
			<TipoGestao>Ativa</TipoGestao>
			<SegmentoAtuacao>Multicategoria</SegmentoAtuacao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>31/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>true</Bolsa>
			<MBO>true</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>true</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>XP INVESTIMENTOS CORRETORA DE CÂMBIO, TÍTULOS E VAL MOB S/A</NomeAdministrador>
		<CNPJAdministrador>02.332.886/0001-04</CNPJAdministrador>
		<Logradouro>AVENIDA ATAULFO DE PAIVA</Logradouro>
		<Numero>153</Numero>
		<Complemento>5º e 8º andares</Complemento>
		<Bairro>LEBLON</Bairro>
		<Cidade>RIO DE JANEIRO</Cidade>
		<Estado>RJ</Estado>
		<CEP>22440-033</CEP>
		<Telefone1>(11) 3027-2237</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.xpi.com.br</Site>
		<Email>adm.fundos.estruturados@xpi.com.br</Email>
		<Competencia>2025-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>HCO GROUP S.A</Nome>
				<CNPJ>54.173.528/0001-91</CNPJ>
				<Endereco>Rua Iguatemi, nº 448, Conjuntos 1002, 1004, 1006, 1008 e 1010, 10º andar, Bairro Itaim 
Bibi, CEP 01451-010</Endereco>
				<telefone>(11) 7310-2024</telefone>
			</Gestor>
			<Custodiante>
				<Nome>OLIVEIRA TRUST DTVM S.A.</Nome>
				<CNPJ>36113876000191</CNPJ>
				<Endereco>Avenida das Américas, n.º 3434, Bloco 07, Sala 201, Barra da Tijuca, Rio de Janeiro/RJ
CEP 22631-000</Endereco>
				<telefone>(21) 3514-0000</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>PRICEWATERHOUSECOOPERS AUDITORES INDEPENDENTES LTDA</Nome>
				<CNPJ>61.562.112/0001-20</CNPJ>
				<Endereco>AV BRIG FARIA LIMA 3732, ANDAR 16 - PARTES 1 A 6, ITAIM BIBI, São Paulo - SP</Endereco>
				<telefone>(11) 4004-8000</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>XP INVESTIMENTOS CCTVM S.A.</Nome>
				<CNPJ>2332886000104</CNPJ>
				<Endereco>AVENIDA ATAULFO DE PAIVA, nº 153, SALA 201, LEBLON, RIO DE JANEIRO, RJ
CEP 90010-040</Endereco>
				<telefone>(11) 3027-2237</telefone>
			</DistribuidorCotas>
			<ConsultorEspecializado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</ConsultorEspecializado>
			<EmpEspecializadaAdmLocacoes>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</EmpEspecializadaAdmLocacoes>
			<OutrosPrestadores>
			</OutrosPrestadores>
		</PrestadoresServicos>
		<InvestimentosFII>
			<NegociosRealizadosPeriodo>
				<RelacaoAtivosAdquiridos>
					<Ativo>
						<Nome>OT SOBERANO</Nome>
						<Objetivos>Ativo mantido por necessidade de liquidez.</Objetivos>
						<MontantesInvestidos>7988123.02</MontantesInvestidos>
						<OrigemRecursos>Recursos de caixa </OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>N/A</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>N/A</ResultadoFundo>
			<ConjunturaEconomica>N/A</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>N/A</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>BLUECAP LOG SPE LTDA</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>0</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>2.944 - MAT</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>55052717.3</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>MAT - 6759</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>24900000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>MAT - 6759</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>63000000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>2.943 - MAT</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>105347282.7</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>MAT - 5.778</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>43000000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>MAT - 5.778</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>7100000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>21.938 - MAT</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>42500000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>21.938 - MAT</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>43400000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>MAT - 20.928</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>195134142</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>É utilizado o critério de marcação a mercado, conforme manual de precificação do custodiante disponível no site https://www.oliveiratrust.com.br.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos>Não possui informaçao apresentada. </AnaliseImpactos>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>AVENIDA ATAULFO DE PAIVA 153, 5º ANDAR, LEBLON, RIO DE JANEIRO - RJ, CEP: 22440-032</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>assembleia.cotista@xpi.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>Endereço eletrônico: assembleia.cotista@xpi.com.br</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>Poderão participar da Assembleia os cotistas inscritos no registro de cotistas do Fundo na data da convocação da respectiva Assembleia, seus representantes legais ou procuradores legalmente constituídos há menos de 1 (um) ano. Sendo assim, é necessário apresentar documento de identificação válido, no caso de cotista pessoa física, ou em caso de pessoa jurídica ou fundo de investimento, documento de identificação válido do(s) representante(s) acompanhado de cópia autenticada do estatuto/contrato social ou cópia simples do regulamento e procuração específica para comprovar poderes. Em caso de cotista representado por procurador, a procuração deve trazer poderes específicos para prática do voto e estar com firma reconhecida. No caso de consultas formais, deverão ser observados os prazos e condições específicas a cada consulta conforme detalhado em seu edital, observado sempre o prazo mínimo previsto em regulamento e na regulamentação vigente. O procedimento para verificação da qualidade de cotista e sua representação acima descrita também é aplicável neste caso.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>A Assembleia Geral de Cotistas será instalada com a presença de pelo menos 01 (um) Cotista, sendo que as deliberações poderão ser realizadas mediante processo de consulta formal, sem a necessidade de reunião presencial de cotistas, por meio de correspondência escrita ou eletrônica (e-mail), plataforma eletrônica ou via mecanismo digital “click through”, a ser realizado pelo Administrador junto a cada Cotista do Fundo, desde que observadas as formalidades previstas na Instrução CVM 472.  Cada Cota corresponderá ao direito de 01 (um) voto na Assembleia Geral de Cotistas.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>– A ADMINISTRADORA e a GESTORA receberão por seus serviços, respectivamente, uma taxa composta: (i) pelo valor equivalente a 0,20% (vinte centésimos por cento) ao ano, observado 
o valor mínimo mensal de R$ 20.000,00 (vinte mil reais), atualizado anualmente segundo a variação positiva do Índice Nacional de Preços ao Consumidor Amplo, divulgado pelo Instituto 
Brasileiro de Geografia e Pesquisa (“IPCA-IBGE”), pro rata die, até ao 5º (quinto) Dia Útil do mês subsequente à data da primeira integralização na CLASSE ÚNICA (“Remuneração da 
Administradora”); e (ii) 0,85% (oitenta e cinco centésimos por cento) ao ano, relativo à prestação de serviços de gestão da carteira de valores mobiliários da CLASSE ÚNICA pela GESTORA
(“Remuneração da Gestora”, e quando referida em conjunto com a Remuneração da Administradora, “Taxa de Administração”), calculada sobre (a) o valor contábil do patrimônio 
líquido total da CLASSE ÚNICA, ou (b) caso as cotas do FUNDO tenham integrado ou passado a integrar, no período, índices de mercado, cuja metodologia preveja critérios de inclusão que 
considerem a liquidez das cotas e critérios de ponderação que considerem o volume financeiro das cotas emitidas pelo FUNDO, como por exemplo, o IFIX, sobre o valor de mercado do FUNDO, calculado com base na média diária da cotação de fechamento das cotas de emissão do FUNDOno mês anterior ao do pagamento da remuneração (“Base de Cálculo da Taxa de Administração”); e que deverá ser pago diretamente à ADMINISTRADORA ou à GESTORA, conforme aplicável. A Remuneração da Administradora será calculada mensalmente por período vencido e paga, até o 5º (quinto) Dia Útil do mês subsequente ao mês em que os serviços forem prestados. </PoliticaRemuneracao>
			<ValorPagoAno>0</ValorPagoAno>
			<PercentPatrimonioContabil>0</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0</PercentPatrimonioValorMercado>
		</RemuneracaoAdministrador>
		<Governanca>
			<RepresentantesCotistas>
				<Representante1>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal xsi:nil="true"/>
						<CondenacaoProcAdminCVM xsi:nil="true"/>
					</Eventos>
				</Representante1>
				<Representante2>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal/>
						<CondenacaoProcAdminCVM/>
					</Eventos>
				</Representante2>
				<Representante3>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal/>
						<CondenacaoProcAdminCVM/>
					</Eventos>
				</Representante3>
				<Representante4>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal/>
						<CondenacaoProcAdminCVM/>
					</Eventos>
				</Representante4>
				<Representante5>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal/>
						<CondenacaoProcAdminCVM/>
					</Eventos>
				</Representante5>
			</RepresentantesCotistas>
			<DiretorResponsavel>
				<Nome>Lizandro Sommer Arnoni</Nome>
				<Idade>50</Idade>
				<CPF>279.902.288-07</CPF>
				<Email>Jurídico.regulatorio@xpi.com.br</Email>
				<Profissao>Administrador</Profissao>
				<FormacaoAcademica>Administração de Empresas</FormacaoAcademica>
				<DataInicioFuncao>2021-09-29</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>XP Investimentos CCTVM S.A.</NomeEmpresa>
						<Periodo>Desde setembro de 2021</Periodo>
						<CargoFuncoes>Diretor de Administração Fiduciária</CargoFuncoes>
						<AtividadePrincipalEmpresa>Diretor responsável pelos serviços de administração fiduciária</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>BNY Mellon Serviços Financeiros DTVM</NomeEmpresa>
						<Periodo>março de 2015 a agosto de 2021</Periodo>
						<CargoFuncoes>Diretor Executivo</CargoFuncoes>
						<AtividadePrincipalEmpresa>Diretor Executivo responsável pelos serviços de administração fiduciária, custódia e controladoria</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal>Não</CondenacaoCriminal>
					<CondenacaoProcAdminCVM>Não</CondenacaoProcAdminCVM>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="36" numCotasDetidas="837" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaCincoAteDezPorcento numCotistas="2" numCotasDetidas="3499172" percDetidoRelTotal="0.1485" percDetidoPF="0" percDetidoPJ="0.1485"/>
			<AcimaDezAteQuinzePorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaQuinzeAteVintePorcento numCotistas="1" numCotasDetidas="4250000" percDetidoRelTotal="0.1804" percDetidoPF="0" percDetidoPJ="0.1804"/>
			<AcimaVinteAteTrintaPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaTrintaAteQuarentaPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaQuarentaAteCinquentaPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaCiquentaPorcento numCotistas="1" numCotasDetidas="15812038" percDetidoRelTotal="0.6711" percDetidoPF="0" percDetidoPJ="0.6711"/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>Todos os atos ou fatos relevantes do Fundo são divulgados na página do Administrador (www.xpi.com.br/administracao-fiduciaria/), do Fundo e sistema FundosNet da B3 S.A.- Brasil, Bolsa e Balcão (˜B3˜).</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>O Fundo não possui política de negociação de cotas.</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>A Política de Exercício de Direito de Votos está disponível no site do Gestor</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao>N/A</FuncResponsaveisPoliticaDivulgacao>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>Não há chamada de capital prevista para o fundo.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"